blob: bafd6251fb3126ba4a57fc186426eae27d06a8b6 [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
Vinh Tran367d89d2023-04-28 11:21:25 -040030 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070031 "android/soong/android"
Sam Delmerico5fb794a2023-01-27 16:01:37 -050032 "android/soong/bazel/cquery"
Colin Crossb98c8b02016-07-29 13:44:28 -070033 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070034 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070035 "android/soong/genrule"
Kiyoung Kim487689e2022-07-26 09:48:22 +090036 "android/soong/multitree"
Rob Seymour925aa092021-08-10 20:42:03 +000037 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080038)
39
Colin Cross463a90e2015-06-17 14:20:06 -070040func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000041 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070042
Paul Duffin036e7002019-12-19 19:16:28 +000043 pctx.Import("android/soong/cc/config")
44}
45
46func RegisterCCBuildComponents(ctx android.RegistrationContext) {
47 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
48
49 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000050 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090051 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070052 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010053 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070054 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070055 ctx.BottomUp("begin", BeginMutator).Parallel()
Vinh Tran44cb78c2023-03-09 22:07:19 -050056 ctx.BottomUp("fdo_profile", fdoProfileMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070057 })
Colin Cross16b23492016-01-06 14:41:07 -080058
Paul Duffin036e7002019-12-19 19:16:28 +000059 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040060 for _, san := range Sanitizers {
61 san.registerMutators(ctx)
62 }
Dan Willemsen581341d2017-02-09 16:16:31 -080063
Colin Cross0b908332019-06-19 23:00:20 -070064 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090065 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080066
Cory Barkera1da26f2022-06-07 20:12:06 +000067 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000068
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080069 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070070
Yi Kongeb8efc92021-12-09 18:06:29 +080071 ctx.TopDown("afdo_deps", afdoDepsMutator)
72 ctx.BottomUp("afdo", afdoMutator).Parallel()
73
Stephen Craneba090d12017-05-09 15:44:35 -070074 ctx.TopDown("lto_deps", ltoDepsMutator)
75 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090076
Jooyung Han479ca172020-10-19 18:51:07 +090077 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090078 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070079 })
Colin Crossb98c8b02016-07-29 13:44:28 -070080
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080081 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
82 // sabi mutator needs to be run after apex mutator finishes.
83 ctx.TopDown("sabi_deps", sabiDepsMutator)
84 })
85
LaMont Jones0c10e4d2023-05-16 00:58:37 +000086 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070087}
88
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050089// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
90// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
91// edges to these modules.
92// This object is constructed in DepsMutator, by calling to various module delegates to set
93// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
94// dependencies.
95// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
96// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080097type Deps struct {
98 SharedLibs, LateSharedLibs []string
99 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800100 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800101 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700102
Colin Cross3e5e7782022-06-17 22:17:05 +0000103 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
104 // prevent automatically exporting symbols.
105 UnexportedStaticLibs []string
106
Chris Parsons79d66a52020-06-05 17:26:16 -0400107 // Used for data dependencies adjacent to tests
108 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700109 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400110
Yo Chiang219968c2020-09-22 18:45:04 +0800111 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
112 SystemSharedLibs []string
113
Vinh Tran367d89d2023-04-28 11:21:25 -0400114 // Used by DepMutator to pass aidl_library modules to aidl compiler
115 AidlLibs []string
116
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500117 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800118 StaticUnwinderIfLegacy bool
119
Colin Cross5950f382016-12-13 12:50:57 -0800120 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700121
Colin Cross81413472016-04-11 14:37:39 -0700122 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700123
Dan Willemsenb40aab62016-04-20 14:21:14 -0700124 GeneratedSources []string
125 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900126 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700127
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700128 ReexportGeneratedHeaders []string
129
Colin Crossc465efd2021-06-11 18:00:04 -0700130 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700131
132 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700133 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900134
135 // List of libs that need to be excluded for APEX variant
136 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700137}
138
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500139// PathDeps is a struct containing file paths to dependencies of a module.
140// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
141// It's used to construct flags for various build statements (such as for compiling and linking).
142// It is then passed to module decorator functions responsible for registering build statements
143// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800144type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700145 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900146 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700147 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900148 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700149 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700150 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700151
Colin Cross0de8a1e2020-09-18 14:15:30 -0700152 // Transitive static library dependencies of static libraries for use in ordering.
153 TranstiveStaticLibrariesForOrdering *android.DepSet
154
Colin Cross26c34ed2016-09-30 17:10:16 -0700155 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100156 Objs Objects
157 // Paths to .o files in dependencies that provide them. Note that these lists
158 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800159 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700160 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700161
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100162 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
163 // the libs from all whole_static_lib dependencies.
164 WholeStaticLibsFromPrebuilts android.Paths
165
Colin Cross26c34ed2016-09-30 17:10:16 -0700166 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700167 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900168 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700169
Inseob Kimd110f872019-12-06 13:15:38 +0900170 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000171 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900172 IncludeDirs android.Paths
173 SystemIncludeDirs android.Paths
174 ReexportedDirs android.Paths
175 ReexportedSystemDirs android.Paths
176 ReexportedFlags []string
177 ReexportedGeneratedHeaders android.Paths
178 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700179
Colin Cross26c34ed2016-09-30 17:10:16 -0700180 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700181 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700182
Dan Willemsena0790e32018-10-12 00:24:23 -0700183 // Path to the dynamic linker binary
184 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700185
186 // For Darwin builds, the path to the second architecture's output that should
187 // be combined with this architectures's output into a FAT MachO file.
188 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400189
190 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
191 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700192}
193
Colin Cross4af21ed2019-11-04 09:37:55 -0800194// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
195// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
196// command line so they can be overridden by the local module flags).
197type LocalOrGlobalFlags struct {
198 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700199 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800200 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700201 CFlags []string // Flags that apply to C and C++ source files
202 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
203 ConlyFlags []string // Flags that apply to C source files
204 CppFlags []string // Flags that apply to C++ source files
205 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700206 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800207}
208
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500209// Flags contains various types of command line flags (and settings) for use in building build
210// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800211type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500212 // Local flags (which individual modules are responsible for). These may override global flags.
213 Local LocalOrGlobalFlags
214 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800215 Global LocalOrGlobalFlags
216
217 aidlFlags []string // Flags that apply to aidl source files
218 rsFlags []string // Flags that apply to renderscript source files
219 libFlags []string // Flags to add libraries early to the link order
220 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
221 TidyFlags []string // Flags that apply to clang-tidy
222 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700223
Colin Crossc3199482017-03-30 15:03:04 -0700224 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800225 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700226 SystemIncludeFlags []string
227
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800228 Toolchain config.Toolchain
229 Tidy bool // True if ninja .tidy rules should be generated.
230 NeedTidyFiles bool // True if module link should depend on .tidy files
231 GcovCoverage bool // True if coverage files should be generated.
232 SAbiDump bool // True if header abi dumps should be generated.
233 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800234
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500235 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800236 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500237 // The target-device system path to the dynamic linker.
238 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800239
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700240 CFlagsDeps android.Paths // Files depended on by compiler flags
241 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800242
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500243 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700244 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800245
Colin Cross19878da2019-03-28 14:45:07 -0700246 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700247 protoC bool // Whether to use C instead of C++
248 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700249
250 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200251 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700252}
253
Colin Crossca860ac2016-01-04 14:34:37 -0800254// Properties used to compile all C or C++ modules
255type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700256 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800257 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700258
Jiyong Parkb35a8192020-08-10 15:59:36 +0900259 // The API level that this module is built against. The APIs of this API level will be
260 // visible at build time, but use of any APIs newer than min_sdk_version will render the
261 // module unloadable on older devices. In the future it will be possible to weakly-link new
262 // APIs, making the behavior match Java: such modules will load on older devices, but
263 // calling new APIs on devices that do not support them will result in a crash.
264 //
265 // This property has the same behavior as sdk_version does for Java modules. For those
266 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
267 // does for Java code.
268 //
269 // In addition, setting this property causes two variants to be built, one for the platform
270 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800271 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700272
Jiyong Parkb35a8192020-08-10 15:59:36 +0900273 // Minimum OS API level supported by this C or C++ module. This property becomes the value
274 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
275 // this property is also used to ensure that the min_sdk_version of the containing module is
276 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
277 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
278 // min_sdk_version of the containing APEX. When the module
279 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900280 Min_sdk_version *string
281
Colin Crossc511bc52020-04-07 16:50:32 +0000282 // If true, always create an sdk variant and don't create a platform variant.
283 Sdk_variant_only *bool
284
Jiyong Parkde866cb2018-12-07 23:08:36 +0900285 AndroidMkSharedLibs []string `blueprint:"mutated"`
286 AndroidMkStaticLibs []string `blueprint:"mutated"`
287 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
288 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700289 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900290 HideFromMake bool `blueprint:"mutated"`
291 PreventInstall bool `blueprint:"mutated"`
292 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700293
Yo Chiang219968c2020-09-22 18:45:04 +0800294 // Set by DepsMutator.
295 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
296
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200297 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900298 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200299
300 // The VNDK version this module is built against. If empty, the module is not
301 // build against the VNDK.
302 VndkVersion string `blueprint:"mutated"`
303
304 // Suffix for the name of Android.mk entries generated by this module
305 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800306
307 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
308 // file
309 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900310
Yifan Hong39143a92020-10-26 12:43:12 -0700311 // Make this module available when building for 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 Hong1b3348d2020-01-21 15:53:22 -0800316 Ramdisk_available *bool
317
Yifan Hong39143a92020-10-26 12:43:12 -0700318 // Make this module available when building for vendor ramdisk.
319 // On device without a dedicated recovery partition, the module is only
320 // available after switching root into
321 // /first_stage_ramdisk. To expose the module before switching root, install
322 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700323 Vendor_ramdisk_available *bool
324
Jiyong Parkf9332f12018-02-01 00:54:12 +0900325 // Make this module available when building for recovery
326 Recovery_available *bool
327
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200328 // Used by imageMutator, set by ImageMutatorBegin()
329 CoreVariantNeeded bool `blueprint:"mutated"`
330 RamdiskVariantNeeded bool `blueprint:"mutated"`
331 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
332 RecoveryVariantNeeded bool `blueprint:"mutated"`
333
334 // A list of variations for the "image" mutator of the form
335 //<image name> '.' <version char>, for example, 'vendor.S'
336 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900337
338 // Allows this module to use non-APEX version of libraries. Useful
339 // for building binaries that are started before APEXes are activated.
340 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900341
342 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
343 // see soong/cc/config/vndk.go
344 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900345
346 // Used by vendor snapshot to record dependencies from snapshot modules.
347 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900348 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900349 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000350
Colin Cross1bc94122021-10-28 13:25:54 -0700351 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000352
353 // Set by factories of module types that can only be referenced from variants compiled against
354 // the SDK.
355 AlwaysSdk bool `blueprint:"mutated"`
356
357 // Variant is an SDK variant created by sdkMutator
358 IsSdkVariant bool `blueprint:"mutated"`
359 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
360 // variant to have a ".sdk" suffix.
361 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700362
363 // Normally Soong uses the directory structure to decide which modules
364 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800365 // 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 vendor snapshot.
368 Exclude_from_vendor_snapshot *bool
369
370 // Normally Soong uses the directory structure to decide which modules
371 // should be included (framework) or excluded (non-framework) from the
372 // different snapshots (vendor, recovery, etc.), but this property
373 // allows a partner to exclude a module normally thought of as a
374 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800375 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900376
377 // List of APEXes that this module has private access to for testing purpose. The module
378 // can depend on libraries that are not exported by the APEXes and use private symbols
379 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000380 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800381
382 Target struct {
383 Platform struct {
384 // List of modules required by the core variant.
385 Required []string `android:"arch_variant"`
386
387 // List of modules not required by the core variant.
388 Exclude_required []string `android:"arch_variant"`
389 } `android:"arch_variant"`
390
391 Recovery struct {
392 // List of modules required by the recovery variant.
393 Required []string `android:"arch_variant"`
394
395 // List of modules not required by the recovery variant.
396 Exclude_required []string `android:"arch_variant"`
397 } `android:"arch_variant"`
398 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700399}
400
401type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900402 // whether this module should be allowed to be directly depended by other
403 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900404 // If set to true, two variants will be built separately, one like
405 // normal, and the other limited to the set of libraries and headers
406 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700407 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900408 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700409 // so it shouldn't have any unversioned runtime dependencies, or
410 // make assumptions about the system that may not be true in the
411 // future.
412 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900413 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900414 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900415 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900416 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900417 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700418 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
419 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900420
Justin Yunebcf0c52021-01-08 18:00:19 +0900421 // This is the same as the "vendor_available" except that the install path
422 // of the vendor variant is /odm or /vendor/odm.
423 // By replacing "vendor_available: true" with "odm_available: true", the
424 // module will install its vendor variant to the /odm partition or /vendor/odm.
425 // As the modules with "odm_available: true" still create the vendor variants,
426 // they can link to the other vendor modules as the vendor_available modules do.
427 // Also, the vendor modules can link to odm_available modules.
428 //
429 // It may not be used for VNDK modules.
430 Odm_available *bool
431
Justin Yun63e9ec72020-10-29 16:49:43 +0900432 // whether this module should be allowed to be directly depended by other
433 // modules with `product_specific: true` or `product_available: true`.
434 // If set to true, an additional product variant will be built separately
435 // that is limited to the set of libraries and headers that are exposed to
436 // /product modules.
437 //
438 // The product variant may be used with a different (newer) /system,
439 // so it shouldn't have any unversioned runtime dependencies, or
440 // make assumptions about the system that may not be true in the
441 // future.
442 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900443 // If set to false, this module becomes inaccessible from /product modules.
444 //
445 // Different from the 'vendor_available' property, the modules with
446 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
447 // library without 'product_available' may not be depended on by any other
448 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900449 //
450 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
451 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
452 Product_available *bool
453
Jiyong Park5fb8c102018-04-09 12:03:06 +0900454 // whether this module is capable of being loaded with other instance
455 // (possibly an older version) of the same module in the same process.
456 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
457 // can be double loaded in a vendor process if the library is also a
458 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
459 // explicitly marked as `double_loadable: true` by the owner, or the dependency
460 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
461 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800462
463 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
464 IsLLNDK bool `blueprint:"mutated"`
465
Colin Cross78212242021-01-06 14:51:30 -0800466 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
467 // set and the module is not listed in VndkMustUseVendorVariantList.
468 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
469
470 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
471 IsVNDKCore bool `blueprint:"mutated"`
472
473 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
474 IsVNDKSP bool `blueprint:"mutated"`
475
476 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
477 // module sets the llndk.private property.
478 IsVNDKPrivate bool `blueprint:"mutated"`
479
480 // IsVNDKProduct is set if a VNDK module sets the product_available property.
481 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700482
483 // IsVendorPublicLibrary is set for the core and product variants of a library that has
484 // vendor_public_library stubs.
485 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800486}
487
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500488// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
489// to understanding details about the type of the current module.
490// For example, one might call these functions to determine whether the current module is a static
491// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800492type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800493 static() bool
494 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700495 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800496 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900497 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900498 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900499 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700500 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900501 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700502 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800503 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900504 minSdkVersion() string
505 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700506 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700507 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800508 IsLlndk() bool
509 IsLlndkPublic() bool
510 isImplementationForLLNDKPublic() bool
511 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900512 isVndk() bool
513 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500514 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700515 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900516 inProduct() bool
517 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800518 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700519 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900520 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700521 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700522 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800523 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800524 isAfdoCompile() bool
Yi Kong7e53c572018-02-14 18:16:12 +0800525 isPgoCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800526 isCfi() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800527 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800528 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800529 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700530 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700531 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900532 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800533 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700534 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700535 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800536 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800537 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800538 getSharedFlags() *SharedFlags
539}
540
541type SharedFlags struct {
542 numSharedFlags int
543 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800544}
545
546type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700547 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800548 ModuleContextIntf
549}
550
551type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700552 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800553 ModuleContextIntf
554}
555
Colin Cross37047f12016-12-13 17:06:13 -0800556type DepsContext interface {
557 android.BottomUpMutatorContext
558 ModuleContextIntf
559}
560
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500561// feature represents additional (optional) steps to building cc-related modules, such as invocation
562// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800563type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800564 flags(ctx ModuleContext, flags Flags) Flags
565 props() []interface{}
566}
567
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500568// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500569// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800570type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700571 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800572 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800573 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700574 compilerProps() []interface{}
575
Colin Cross76fada02016-07-27 10:31:13 -0700576 appendCflags([]string)
577 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700578 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800579}
580
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500581// linker is the interface for a linker decorator object. Individual module types can provide
582// their own implementation for this decorator, and thus specify custom logic regarding build
583// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800584type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700585 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800586 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700587 linkerFlags(ctx ModuleContext, flags Flags) Flags
588 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800589 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700590
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700591 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700592 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900593 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700594
595 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900596 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000597
598 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000599 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
600}
601
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500602// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000603type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500604 sharedLibs []string
605 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
606 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700607 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800608}
609
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500610// installer is the interface for an installer helper object. This helper is responsible for
611// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800612type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700613 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700614 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000615 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800616 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700617 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700618 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900619 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000620 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900621 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800622}
623
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800624type xref interface {
625 XrefCcFiles() android.Paths
626}
627
Inseob Kima1888ce2022-10-04 14:42:02 +0900628type overridable interface {
629 overriddenModules() []string
630}
631
Colin Cross6e511a92020-07-27 21:26:48 -0700632type libraryDependencyKind int
633
634const (
635 headerLibraryDependency = iota
636 sharedLibraryDependency
637 staticLibraryDependency
638)
639
640func (k libraryDependencyKind) String() string {
641 switch k {
642 case headerLibraryDependency:
643 return "headerLibraryDependency"
644 case sharedLibraryDependency:
645 return "sharedLibraryDependency"
646 case staticLibraryDependency:
647 return "staticLibraryDependency"
648 default:
649 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
650 }
651}
652
653type libraryDependencyOrder int
654
655const (
656 earlyLibraryDependency = -1
657 normalLibraryDependency = 0
658 lateLibraryDependency = 1
659)
660
661func (o libraryDependencyOrder) String() string {
662 switch o {
663 case earlyLibraryDependency:
664 return "earlyLibraryDependency"
665 case normalLibraryDependency:
666 return "normalLibraryDependency"
667 case lateLibraryDependency:
668 return "lateLibraryDependency"
669 default:
670 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
671 }
672}
673
674// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
675// tags that have a set of predefined tag objects that are reused for each dependency, a
676// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
677// That means that comparing a libraryDependencyTag for equality will only be equal if all
678// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
679// then check individual metadata fields instead.
680type libraryDependencyTag struct {
681 blueprint.BaseDependencyTag
682
683 // These are exported so that fmt.Printf("%#v") can call their String methods.
684 Kind libraryDependencyKind
685 Order libraryDependencyOrder
686
687 wholeStatic bool
688
689 reexportFlags bool
690 explicitlyVersioned bool
691 dataLib bool
692 ndk bool
693
694 staticUnwinder bool
695
696 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900697
Cindy Zhou18417cb2020-12-10 07:12:38 -0800698 // Whether or not this dependency should skip the apex dependency check
699 skipApexAllowedDependenciesCheck bool
700
Jiyong Parke3867542020-12-03 17:28:25 +0900701 // Whether or not this dependency has to be followed for the apex variants
702 excludeInApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000703
704 // If true, don't automatically export symbols from the static library into a shared library.
705 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700706}
707
708// header returns true if the libraryDependencyTag is tagging a header lib dependency.
709func (d libraryDependencyTag) header() bool {
710 return d.Kind == headerLibraryDependency
711}
712
713// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
714func (d libraryDependencyTag) shared() bool {
715 return d.Kind == sharedLibraryDependency
716}
717
718// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
719func (d libraryDependencyTag) static() bool {
720 return d.Kind == staticLibraryDependency
721}
722
Colin Cross65cb3142021-12-10 23:05:02 +0000723func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
724 if d.shared() {
725 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
726 }
727 return nil
728}
729
730var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
731
Colin Crosse9fe2942020-11-10 18:12:15 -0800732// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
733// binaries or other shared libraries are installed as dependencies.
734func (d libraryDependencyTag) InstallDepNeeded() bool {
735 return d.shared()
736}
737
738var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
739
740// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700741// libraryDependencyTag. Each tag object is created globally and reused for multiple
742// dependencies (although since the object contains no references, assigning a tag to a
743// variable and modifying it will not modify the original). Users can compare the tag
744// returned by ctx.OtherModuleDependencyTag against the global original
745type dependencyTag struct {
746 blueprint.BaseDependencyTag
747 name string
748}
749
Colin Crosse9fe2942020-11-10 18:12:15 -0800750// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
751// libraryDependencyTag, but where the dependency needs to be installed when the parent is
752// installed.
753type installDependencyTag struct {
754 blueprint.BaseDependencyTag
755 android.InstallAlwaysNeededDependencyTag
756 name string
757}
758
Colin Crossc99deeb2016-04-11 15:06:20 -0700759var (
Colin Cross6e511a92020-07-27 21:26:48 -0700760 genSourceDepTag = dependencyTag{name: "gen source"}
761 genHeaderDepTag = dependencyTag{name: "gen header"}
762 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
763 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900764 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700765 reuseObjTag = dependencyTag{name: "reuse objects"}
766 staticVariantTag = dependencyTag{name: "static variant"}
767 vndkExtDepTag = dependencyTag{name: "vndk extends"}
768 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700769 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800770 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700771 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700772 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000773 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500774 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400775 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700776)
777
Roland Levillainf89cd092019-07-29 16:22:59 +0100778func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700779 ccLibDepTag, ok := depTag.(libraryDependencyTag)
780 return ok && ccLibDepTag.shared()
781}
782
783func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
784 ccLibDepTag, ok := depTag.(libraryDependencyTag)
785 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100786}
787
Zach Johnson3df4e632020-11-06 11:56:27 -0800788func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
789 ccLibDepTag, ok := depTag.(libraryDependencyTag)
790 return ok && ccLibDepTag.header()
791}
792
Roland Levillainf89cd092019-07-29 16:22:59 +0100793func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800794 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100795}
796
797func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700798 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100799 return ok && ccDepTag == testPerSrcDepTag
800}
801
Chris Parsonsf874e462022-05-10 13:50:12 -0400802// bazelHandler is the interface for a helper object related to deferring to Bazel for
803// processing a cc module (during Bazel mixed builds). Individual module types should define
804// their own bazel handler if they support being handled by Bazel.
805type BazelHandler interface {
806 // QueueBazelCall invokes request-queueing functions on the BazelContext
807 //so that these requests are handled when Bazel's cquery is invoked.
808 QueueBazelCall(ctx android.BaseModuleContext, label string)
809
810 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
811 // on the current module with given label.
812 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
813}
814
Colin Crossca860ac2016-01-04 14:34:37 -0800815// Module contains the properties and members used by all C/C++ module types, and implements
816// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500817// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
818// interface.
819//
820// To define a C/C++ related module, construct a new Module object and point its delegates to
821// type-specific structs. These delegates will be invoked to register module-specific build
822// statements which may be unique to the module type. For example, module.compiler.compile() should
823// be defined so as to register build statements which are responsible for compiling the module.
824//
825// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
826// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
827// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
828// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800829type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700830 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700831
Liz Kammerea6666f2021-02-17 10:17:28 -0500832 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700833
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700834 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700835 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700836
Colin Crossca860ac2016-01-04 14:34:37 -0800837 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400838 hod android.HostOrDeviceSupported
839 multilib android.Multilib
840 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700841
Paul Duffina0843f62019-12-13 19:50:38 +0000842 // Allowable SdkMemberTypes of this module type.
843 sdkMemberTypes []android.SdkMemberType
844
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500845 // decorator delegates, initialize before calling Init
846 // these may contain module-specific implementations, and effectively allow for custom
847 // type-specific logic. These members may reference different objects or the same object.
848 // Functions of these decorators will be invoked to initialize and register type-specific
849 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500850 compiler compiler
851 linker linker
852 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400853 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500854
855 features []feature
856 stl *stl
857 sanitize *sanitize
858 coverage *coverage
Cory Barkera1da26f2022-06-07 20:12:06 +0000859 fuzzer *fuzzer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500860 sabi *sabi
861 vndkdep *vndkdep
862 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800863 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500864 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800865
Colin Cross31076b32020-10-23 17:22:06 -0700866 library libraryInterface
867
Colin Cross635c3b02016-05-18 15:37:25 -0700868 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800869
Colin Crossb98c8b02016-07-29 13:44:28 -0700870 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700871
872 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800873
874 // Flags used to compile this module
875 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700876
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800877 // Shared flags among build rules of this module
878 sharedFlags SharedFlags
879
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800880 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700881 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900882
883 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800884 // Kythe (source file indexer) paths for this compilation module
885 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700886 // Object .o file output paths for this compilation module
887 objFiles android.Paths
888 // Tidy .tidy file output paths for this compilation module
889 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900890
891 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700892 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700893
894 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700895}
896
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200897func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400898 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
899 if b, ok := c.compiler.(*baseCompiler); ok {
900 hasAidl = b.hasSrcExt(".aidl")
901 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
902 hasProto = b.hasSrcExt(".proto")
903 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
904 hasSysprop = b.hasSrcExt(".sysprop")
905 hasWinMsg = b.hasSrcExt(".mc")
906 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
907 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200908 c.AndroidModuleBase().AddJSONData(d)
909 (*d)["Cc"] = map[string]interface{}{
910 "SdkVersion": c.SdkVersion(),
911 "MinSdkVersion": c.MinSdkVersion(),
912 "VndkVersion": c.VndkVersion(),
913 "ProductSpecific": c.ProductSpecific(),
914 "SocSpecific": c.SocSpecific(),
915 "DeviceSpecific": c.DeviceSpecific(),
916 "InProduct": c.InProduct(),
917 "InVendor": c.InVendor(),
918 "InRamdisk": c.InRamdisk(),
919 "InVendorRamdisk": c.InVendorRamdisk(),
920 "InRecovery": c.InRecovery(),
921 "VendorAvailable": c.VendorAvailable(),
922 "ProductAvailable": c.ProductAvailable(),
923 "RamdiskAvailable": c.RamdiskAvailable(),
924 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
925 "RecoveryAvailable": c.RecoveryAvailable(),
926 "OdmAvailable": c.OdmAvailable(),
927 "InstallInData": c.InstallInData(),
928 "InstallInRamdisk": c.InstallInRamdisk(),
929 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
930 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
931 "InstallInRecovery": c.InstallInRecovery(),
932 "InstallInRoot": c.InstallInRoot(),
933 "IsVndk": c.IsVndk(),
934 "IsVndkExt": c.IsVndkExt(),
935 "IsVndkPrivate": c.IsVndkPrivate(),
936 "IsVndkSp": c.IsVndkSp(),
937 "IsLlndk": c.IsLlndk(),
938 "IsLlndkPublic": c.IsLlndkPublic(),
939 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
940 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
941 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
942 "ApexSdkVersion": c.apexSdkVersion,
943 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400944 "AidlSrcs": hasAidl,
945 "LexSrcs": hasLex,
946 "ProtoSrcs": hasProto,
947 "RenderscriptSrcs": hasRenderscript,
948 "SyspropSrcs": hasSysprop,
949 "WinMsgSrcs": hasWinMsg,
950 "YaccSrsc": hasYacc,
951 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200952 }
953}
954
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500955func (c *Module) SetPreventInstall() {
956 c.Properties.PreventInstall = true
957}
958
959func (c *Module) SetHideFromMake() {
960 c.Properties.HideFromMake = true
961}
962
Ivan Lozanod7586b62021-04-01 09:49:36 -0400963func (c *Module) HiddenFromMake() bool {
964 return c.Properties.HideFromMake
965}
966
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800967func (c *Module) RequiredModuleNames() []string {
968 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
969 if c.ImageVariation().Variation == android.CoreVariation {
970 required = append(required, c.Properties.Target.Platform.Required...)
971 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
972 } else if c.InRecovery() {
973 required = append(required, c.Properties.Target.Recovery.Required...)
974 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
975 }
976 return android.FirstUniqueStrings(required)
977}
978
Ivan Lozano52767be2019-10-18 14:49:46 -0700979func (c *Module) Toc() android.OptionalPath {
980 if c.linker != nil {
981 if library, ok := c.linker.(libraryInterface); ok {
982 return library.toc()
983 }
984 }
985 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
986}
987
988func (c *Module) ApiLevel() string {
989 if c.linker != nil {
990 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700991 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700992 }
993 }
994 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
995}
996
997func (c *Module) Static() bool {
998 if c.linker != nil {
999 if library, ok := c.linker.(libraryInterface); ok {
1000 return library.static()
1001 }
1002 }
1003 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1004}
1005
1006func (c *Module) Shared() bool {
1007 if c.linker != nil {
1008 if library, ok := c.linker.(libraryInterface); ok {
1009 return library.shared()
1010 }
1011 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001012
Ivan Lozano52767be2019-10-18 14:49:46 -07001013 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1014}
1015
1016func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001017 if c.stl != nil {
1018 return c.stl.Properties.SelectedStl
1019 }
1020 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001021}
1022
Ivan Lozano52767be2019-10-18 14:49:46 -07001023func (c *Module) NdkPrebuiltStl() bool {
1024 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1025 return true
1026 }
1027 return false
1028}
1029
1030func (c *Module) StubDecorator() bool {
1031 if _, ok := c.linker.(*stubDecorator); ok {
1032 return true
1033 }
1034 return false
1035}
1036
1037func (c *Module) SdkVersion() string {
1038 return String(c.Properties.Sdk_version)
1039}
1040
Artur Satayev480e25b2020-04-27 18:53:18 +01001041func (c *Module) MinSdkVersion() string {
1042 return String(c.Properties.Min_sdk_version)
1043}
1044
Jiyong Park5df7bd32021-08-25 16:18:46 +09001045func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001046 if linker, ok := c.linker.(*objectLinker); ok {
1047 return linker.isCrt()
1048 }
1049 return false
1050}
1051
Jiyong Park5df7bd32021-08-25 16:18:46 +09001052func (c *Module) SplitPerApiLevel() bool {
1053 return c.canUseSdk() && c.isCrt()
1054}
1055
Colin Crossc511bc52020-04-07 16:50:32 +00001056func (c *Module) AlwaysSdk() bool {
1057 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1058}
1059
Ivan Lozano183a3212019-10-18 14:18:45 -07001060func (c *Module) CcLibrary() bool {
1061 if c.linker != nil {
1062 if _, ok := c.linker.(*libraryDecorator); ok {
1063 return true
1064 }
Colin Crossd48fe732020-09-23 20:37:24 -07001065 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1066 return true
1067 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001068 }
1069 return false
1070}
1071
1072func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001073 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001074 return true
1075 }
1076 return false
1077}
1078
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001079func (c *Module) IsFuzzModule() bool {
1080 if _, ok := c.compiler.(*fuzzBinary); ok {
1081 return true
1082 }
1083 return false
1084}
1085
1086func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1087 return c.FuzzModule
1088}
1089
1090func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1091 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1092 return fuzzer.fuzzPackagedModule
1093 }
1094 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1095}
1096
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001097func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001098 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1099 return fuzzer.sharedLibraries
1100 }
1101 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1102}
1103
Ivan Lozano2b262972019-11-21 12:30:50 -08001104func (c *Module) NonCcVariants() bool {
1105 return false
1106}
1107
Ivan Lozano183a3212019-10-18 14:18:45 -07001108func (c *Module) SetStatic() {
1109 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001110 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001111 library.setStatic()
1112 return
1113 }
1114 }
1115 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1116}
1117
1118func (c *Module) SetShared() {
1119 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001120 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001121 library.setShared()
1122 return
1123 }
1124 }
1125 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1126}
1127
1128func (c *Module) BuildStaticVariant() bool {
1129 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001130 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001131 return library.buildStatic()
1132 }
1133 }
1134 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1135}
1136
1137func (c *Module) BuildSharedVariant() bool {
1138 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001139 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001140 return library.buildShared()
1141 }
1142 }
1143 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1144}
1145
1146func (c *Module) Module() android.Module {
1147 return c
1148}
1149
Jiyong Parkc20eee32018-09-05 22:36:17 +09001150func (c *Module) OutputFile() android.OptionalPath {
1151 return c.outputFile
1152}
1153
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001154func (c *Module) CoverageFiles() android.Paths {
1155 if c.linker != nil {
1156 if library, ok := c.linker.(libraryInterface); ok {
1157 return library.objs().coverageFiles
1158 }
1159 }
1160 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1161}
1162
Ivan Lozano183a3212019-10-18 14:18:45 -07001163var _ LinkableInterface = (*Module)(nil)
1164
Jiyong Park719b4462019-01-13 00:39:51 +09001165func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001166 if c.linker != nil {
1167 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001168 }
1169 return nil
1170}
1171
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001172func (c *Module) CoverageOutputFile() android.OptionalPath {
1173 if c.linker != nil {
1174 return c.linker.coverageOutputFilePath()
1175 }
1176 return android.OptionalPath{}
1177}
1178
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001179func (c *Module) RelativeInstallPath() string {
1180 if c.installer != nil {
1181 return c.installer.relativeInstallPath()
1182 }
1183 return ""
1184}
1185
Jooyung Han344d5432019-08-23 11:17:39 +09001186func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001187 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001188}
1189
Colin Cross36242852017-06-23 15:06:31 -07001190func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001191 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001192 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001193 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001194 }
1195 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001196 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001197 }
1198 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001199 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001200 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001201 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001202 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001203 }
Colin Cross16b23492016-01-06 14:41:07 -08001204 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001205 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001206 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001207 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001208 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001209 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001210 if c.fuzzer != nil {
1211 c.AddProperties(c.fuzzer.props()...)
1212 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001213 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001214 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001215 }
Justin Yun8effde42017-06-23 19:24:43 +09001216 if c.vndkdep != nil {
1217 c.AddProperties(c.vndkdep.props()...)
1218 }
Stephen Craneba090d12017-05-09 15:44:35 -07001219 if c.lto != nil {
1220 c.AddProperties(c.lto.props()...)
1221 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001222 if c.afdo != nil {
1223 c.AddProperties(c.afdo.props()...)
1224 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001225 if c.pgo != nil {
1226 c.AddProperties(c.pgo.props()...)
1227 }
Colin Crossca860ac2016-01-04 14:34:37 -08001228 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001229 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001230 }
Colin Crossc472d572015-03-17 15:06:21 -07001231
Colin Cross36242852017-06-23 15:06:31 -07001232 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001233 if c.bazelable {
1234 android.InitBazelModule(c)
1235 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001236 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001237 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001238
Colin Cross36242852017-06-23 15:06:31 -07001239 return c
Colin Crossc472d572015-03-17 15:06:21 -07001240}
1241
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001242// UseVndk() returns true if this module is built against VNDK.
1243// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001244func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001245 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001246}
1247
Colin Crossc511bc52020-04-07 16:50:32 +00001248func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001249 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1250 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001251}
1252
1253func (c *Module) UseSdk() bool {
1254 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001255 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001256 }
1257 return false
1258}
1259
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001260func (c *Module) isCoverageVariant() bool {
1261 return c.coverage.Properties.IsCoverageVariant
1262}
1263
Colin Cross95f1ca02020-10-29 20:47:22 -07001264func (c *Module) IsNdk(config android.Config) bool {
1265 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001266}
1267
Colin Cross127bb8b2020-12-16 16:46:01 -08001268func (c *Module) IsLlndk() bool {
1269 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001270}
1271
Colin Cross127bb8b2020-12-16 16:46:01 -08001272func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001273 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001274}
1275
Colin Cross1f3f1302021-04-26 18:37:44 -07001276func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001277 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001278 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001279}
1280
Colin Cross5271fea2021-04-27 13:06:04 -07001281func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1282 lib := moduleLibraryInterface(m)
1283 return lib != nil && (lib.hasVendorPublicLibrary())
1284}
1285
1286// IsVendorPublicLibrary returns true for vendor public libraries.
1287func (c *Module) IsVendorPublicLibrary() bool {
1288 return c.VendorProperties.IsVendorPublicLibrary
1289}
1290
Ivan Lozanof1868af2022-04-12 13:08:36 -04001291func (c *Module) IsVndkPrebuiltLibrary() bool {
1292 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1293 return true
1294 }
1295 return false
1296}
1297
1298func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1299 return c.Properties.SdkAndPlatformVariantVisibleToMake
1300}
1301
Ivan Lozanod7586b62021-04-01 09:49:36 -04001302func (c *Module) HasLlndkStubs() bool {
1303 lib := moduleLibraryInterface(c)
1304 return lib != nil && lib.hasLLNDKStubs()
1305}
1306
1307func (c *Module) StubsVersion() string {
1308 if lib, ok := c.linker.(versionedInterface); ok {
1309 return lib.stubsVersion()
1310 }
1311 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1312}
1313
Colin Cross127bb8b2020-12-16 16:46:01 -08001314// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1315// and does not set llndk.vendor_available: false.
1316func (c *Module) isImplementationForLLNDKPublic() bool {
1317 library, _ := c.library.(*libraryDecorator)
1318 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001319 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001320}
1321
Justin Yunfd9e8042020-12-23 18:23:14 +09001322// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001323func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001324 // Check if VNDK-core-private or VNDK-SP-private
1325 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001326 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001327 }
1328
1329 // Check if LLNDK-private
1330 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001331 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001332 }
1333
1334 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001335}
1336
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001337// IsVndk() returns true if this module has a vndk variant.
1338// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1339// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001340func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001341 if vndkdep := c.vndkdep; vndkdep != nil {
1342 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001343 }
1344 return false
1345}
1346
Yi Kong4ef54592022-02-14 20:00:10 +08001347func (c *Module) isAfdoCompile() bool {
1348 if afdo := c.afdo; afdo != nil {
Vinh Tran44cb78c2023-03-09 22:07:19 -05001349 return afdo.Properties.FdoProfilePath != nil
Yi Kong4ef54592022-02-14 20:00:10 +08001350 }
1351 return false
1352}
1353
Yi Kong7e53c572018-02-14 18:16:12 +08001354func (c *Module) isPgoCompile() bool {
1355 if pgo := c.pgo; pgo != nil {
1356 return pgo.Properties.PgoCompile
1357 }
1358 return false
1359}
1360
Yi Kongc702ebd2022-08-19 16:02:45 +08001361func (c *Module) isCfi() bool {
1362 if sanitize := c.sanitize; sanitize != nil {
1363 return Bool(sanitize.Properties.Sanitize.Cfi)
1364 }
1365 return false
1366}
1367
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001368func (c *Module) isNDKStubLibrary() bool {
1369 if _, ok := c.compiler.(*stubDecorator); ok {
1370 return true
1371 }
1372 return false
1373}
1374
Ivan Lozanod7586b62021-04-01 09:49:36 -04001375func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001376 if vndkdep := c.vndkdep; vndkdep != nil {
1377 return vndkdep.isVndkSp()
1378 }
1379 return false
1380}
1381
Ivan Lozanof9e21722020-12-02 09:00:51 -05001382func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001383 if vndkdep := c.vndkdep; vndkdep != nil {
1384 return vndkdep.isVndkExt()
1385 }
1386 return false
1387}
1388
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001389func (c *Module) SubName() string {
1390 return c.Properties.SubName
1391}
1392
Ivan Lozano52767be2019-10-18 14:49:46 -07001393func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001394 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001395}
1396
Logan Chienf3511742017-10-31 18:04:35 +08001397func (c *Module) getVndkExtendsModuleName() string {
1398 if vndkdep := c.vndkdep; vndkdep != nil {
1399 return vndkdep.getVndkExtendsModuleName()
1400 }
1401 return ""
1402}
1403
Jiyong Park25fc6a92018-11-18 18:02:45 +09001404func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001405 if lib := c.library; lib != nil {
1406 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001407 }
1408 return false
1409}
1410
1411func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001412 if lib := c.library; lib != nil {
1413 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001414 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001415 return false
1416}
1417
Alan Stokes73feba32022-11-14 12:21:24 +00001418func (c *Module) IsStubsImplementationRequired() bool {
1419 if lib := c.library; lib != nil {
1420 return lib.isStubsImplementationRequired()
1421 }
1422 return false
1423}
1424
Colin Cross0477b422020-10-13 18:43:54 -07001425// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1426// the implementation. If it is an implementation library it returns its own name.
1427func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1428 name := ctx.OtherModuleName(c)
1429 if versioned, ok := c.linker.(versionedInterface); ok {
1430 name = versioned.implementationModuleName(name)
1431 }
1432 return name
1433}
1434
Martin Stjernholm2856c662020-12-02 15:03:42 +00001435// Similar to ImplementationModuleName, but uses the Make variant of the module
1436// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1437// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1438// under the premise that the prebuilt module overrides its source counterpart
1439// if it is exposed to Make).
1440func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1441 name := c.BaseModuleName()
1442 if versioned, ok := c.linker.(versionedInterface); ok {
1443 name = versioned.implementationModuleName(name)
1444 }
1445 return name
1446}
1447
Jiyong Park7d55b612021-06-11 17:22:09 +09001448func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001449 return Bool(c.Properties.Bootstrap)
1450}
1451
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001452func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001453 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1454 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1455 return false
1456 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001457 return c.linker != nil && c.linker.nativeCoverage()
1458}
1459
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001460func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001461 if p, ok := c.linker.(SnapshotInterface); ok {
1462 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001463 }
1464 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001465}
1466
Bill Peckham945441c2020-08-31 16:07:58 -07001467func (c *Module) ExcludeFromVendorSnapshot() bool {
1468 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1469}
1470
Jose Galmesf7294582020-11-13 12:07:36 -08001471func (c *Module) ExcludeFromRecoverySnapshot() bool {
1472 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1473}
1474
Jiyong Parkf1194352019-02-25 11:05:47 +09001475func isBionic(name string) bool {
1476 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001477 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001478 return true
1479 }
1480 return false
1481}
1482
Martin Stjernholm279de572019-09-10 23:18:20 +01001483func InstallToBootstrap(name string, config android.Config) bool {
Jingwen Chen29743c82023-01-25 17:49:46 +00001484 // NOTE: also update //build/bazel/rules/apex/cc.bzl#_installed_to_bootstrap
1485 // if this list is updated.
Florian Mayer95cd6db2023-03-23 17:48:07 -07001486 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001487 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001488 }
1489 return isBionic(name)
1490}
1491
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001492func (c *Module) XrefCcFiles() android.Paths {
1493 return c.kytheFiles
1494}
1495
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001496func (c *Module) isCfiAssemblySupportEnabled() bool {
1497 return c.sanitize != nil &&
1498 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1499}
1500
Inseob Kim800d1142021-06-14 12:03:51 +09001501func (c *Module) InstallInRoot() bool {
1502 return c.installer != nil && c.installer.installInRoot()
1503}
1504
Colin Crossca860ac2016-01-04 14:34:37 -08001505type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001506 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001507 moduleContextImpl
1508}
1509
Colin Cross37047f12016-12-13 17:06:13 -08001510type depsContext struct {
1511 android.BottomUpMutatorContext
1512 moduleContextImpl
1513}
1514
Colin Crossca860ac2016-01-04 14:34:37 -08001515type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001516 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001517 moduleContextImpl
1518}
1519
1520type moduleContextImpl struct {
1521 mod *Module
1522 ctx BaseModuleContext
1523}
1524
Colin Crossb98c8b02016-07-29 13:44:28 -07001525func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001526 return ctx.mod.toolchain(ctx.ctx)
1527}
1528
1529func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001530 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001531}
1532
1533func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001534 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001535}
1536
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001537func (ctx *moduleContextImpl) testBinary() bool {
1538 return ctx.mod.testBinary()
1539}
1540
Yi Kong56fc1b62022-09-06 16:24:00 +08001541func (ctx *moduleContextImpl) testLibrary() bool {
1542 return ctx.mod.testLibrary()
1543}
1544
Jiyong Park1d1119f2019-07-29 21:27:18 +09001545func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001546 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001547}
1548
Inseob Kim7f283f42020-06-01 21:53:49 +09001549func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001550 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001551}
1552
Inseob Kim1042d292020-06-01 23:23:05 +09001553func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001554 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001555}
1556
Jooyung Hanccce2f22020-03-07 03:45:53 +09001557func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001558 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001559}
1560
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001561func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001562 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001563}
1564
1565func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001566 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001567 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001568 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001569 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001570 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001571 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001572 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001573 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001574 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001575 }
1576 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001577}
1578
Jiyong Parkb35a8192020-08-10 15:59:36 +09001579func (ctx *moduleContextImpl) minSdkVersion() string {
1580 ver := ctx.mod.MinSdkVersion()
1581 if ver == "apex_inherit" && !ctx.isForPlatform() {
1582 ver = ctx.apexSdkVersion().String()
1583 }
1584 if ver == "apex_inherit" || ver == "" {
1585 ver = ctx.sdkVersion()
1586 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001587 // For crt objects, the meaning of min_sdk_version is very different from other types of
1588 // module. For them, min_sdk_version defines the oldest version that the build system will
1589 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1590 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1591 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001592 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1593 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1594 // support such an old version. The version is set to the later version in case when the
1595 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1596 // it's for an APEX.
1597 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1598 if ctx.isForPlatform() {
1599 ver = strconv.Itoa(android.FutureApiLevelInt)
1600 } else { // for apex
1601 ver = ctx.apexSdkVersion().String()
1602 if ver == "" { // in case when min_sdk_version was not set by the APEX
1603 ver = ctx.sdkVersion()
1604 }
1605 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001606 }
1607
Jiyong Parkb35a8192020-08-10 15:59:36 +09001608 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1609 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1610 minSdkVersionInt, err2 := strconv.Atoi(ver)
1611 if err == nil && err2 == nil {
1612 if sdkVersionInt < minSdkVersionInt {
1613 return strconv.Itoa(sdkVersionInt)
1614 }
1615 }
1616 return ver
1617}
1618
1619func (ctx *moduleContextImpl) isSdkVariant() bool {
1620 return ctx.mod.IsSdkVariant()
1621}
1622
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001623func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001624 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001625}
Justin Yun8effde42017-06-23 19:24:43 +09001626
Colin Cross95f1ca02020-10-29 20:47:22 -07001627func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1628 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001629}
1630
Colin Cross127bb8b2020-12-16 16:46:01 -08001631func (ctx *moduleContextImpl) IsLlndk() bool {
1632 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001633}
1634
Colin Cross127bb8b2020-12-16 16:46:01 -08001635func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1636 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001637}
1638
Colin Cross127bb8b2020-12-16 16:46:01 -08001639func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1640 return ctx.mod.isImplementationForLLNDKPublic()
1641}
1642
1643func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1644 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001645}
1646
Logan Chienf3511742017-10-31 18:04:35 +08001647func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001648 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001649}
1650
Yi Kong4ef54592022-02-14 20:00:10 +08001651func (ctx *moduleContextImpl) isAfdoCompile() bool {
1652 return ctx.mod.isAfdoCompile()
1653}
1654
Yi Kong7e53c572018-02-14 18:16:12 +08001655func (ctx *moduleContextImpl) isPgoCompile() bool {
1656 return ctx.mod.isPgoCompile()
1657}
1658
Yi Kongc702ebd2022-08-19 16:02:45 +08001659func (ctx *moduleContextImpl) isCfi() bool {
1660 return ctx.mod.isCfi()
1661}
1662
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001663func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1664 return ctx.mod.isNDKStubLibrary()
1665}
1666
Justin Yun8effde42017-06-23 19:24:43 +09001667func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001668 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001669}
1670
Ivan Lozanof9e21722020-12-02 09:00:51 -05001671func (ctx *moduleContextImpl) IsVndkExt() bool {
1672 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001673}
1674
Colin Cross5271fea2021-04-27 13:06:04 -07001675func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1676 return ctx.mod.IsVendorPublicLibrary()
1677}
1678
Vic Yangefd249e2018-11-12 20:19:56 -08001679func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001680 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001681}
1682
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001683func (ctx *moduleContextImpl) selectedStl() string {
1684 if stl := ctx.mod.stl; stl != nil {
1685 return stl.Properties.SelectedStl
1686 }
1687 return ""
1688}
1689
Ivan Lozanobd721262018-11-27 14:33:03 -08001690func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1691 return ctx.mod.linker.useClangLld(actx)
1692}
1693
Colin Crossce75d2c2016-10-06 16:12:58 -07001694func (ctx *moduleContextImpl) baseModuleName() string {
1695 return ctx.mod.ModuleBase.BaseModuleName()
1696}
1697
Logan Chienf3511742017-10-31 18:04:35 +08001698func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1699 return ctx.mod.getVndkExtendsModuleName()
1700}
1701
Logan Chiene274fc92019-12-03 11:18:32 -08001702func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001703 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001704}
1705
Colin Crosse07f2312020-08-13 11:24:56 -07001706func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001707 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001708}
1709
Dan Albertc8060532020-07-22 22:32:17 -07001710func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001711 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001712}
1713
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001714func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001715 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001716}
1717
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001718func (ctx *moduleContextImpl) nativeCoverage() bool {
1719 return ctx.mod.nativeCoverage()
1720}
1721
Colin Cross56a83212020-09-15 18:30:11 -07001722func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1723 return ctx.mod.DirectlyInAnyApex()
1724}
1725
Colin Cross95b07f22020-12-16 11:06:50 -08001726func (ctx *moduleContextImpl) isPreventInstall() bool {
1727 return ctx.mod.Properties.PreventInstall
1728}
1729
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001730func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1731 shared := &ctx.mod.sharedFlags
1732 if shared.flagsMap == nil {
1733 shared.numSharedFlags = 0
1734 shared.flagsMap = make(map[string]string)
1735 }
1736 return shared
1737}
1738
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001739func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1740 return ctx.mod.isCfiAssemblySupportEnabled()
1741}
1742
Colin Cross635c3b02016-05-18 15:37:25 -07001743func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001744 return &Module{
1745 hod: hod,
1746 multilib: multilib,
1747 }
1748}
1749
Colin Cross635c3b02016-05-18 15:37:25 -07001750func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001751 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001752 module.features = []feature{
1753 &tidyFeature{},
1754 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001755 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001756 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001757 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001758 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001759 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001760 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001761 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001762 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001763 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001764 return module
1765}
1766
Colin Crossce75d2c2016-10-06 16:12:58 -07001767func (c *Module) Prebuilt() *android.Prebuilt {
1768 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1769 return p.prebuilt()
1770 }
1771 return nil
1772}
1773
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001774func (c *Module) IsPrebuilt() bool {
1775 return c.Prebuilt() != nil
1776}
1777
Colin Crossce75d2c2016-10-06 16:12:58 -07001778func (c *Module) Name() string {
1779 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001780 if p, ok := c.linker.(interface {
1781 Name(string) string
1782 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001783 name = p.Name(name)
1784 }
1785 return name
1786}
1787
Alex Light3d673592019-01-18 14:37:31 -08001788func (c *Module) Symlinks() []string {
1789 if p, ok := c.installer.(interface {
1790 symlinkList() []string
1791 }); ok {
1792 return p.symlinkList()
1793 }
1794 return nil
1795}
1796
Roland Levillainf89cd092019-07-29 16:22:59 +01001797func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1798 test, ok := c.linker.(testPerSrc)
1799 return ok && test.isAllTestsVariation()
1800}
1801
Chris Parsons216e10a2020-07-09 17:12:52 -04001802func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001803 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001804 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001805 }); ok {
1806 return p.dataPaths()
1807 }
1808 return nil
1809}
1810
Ivan Lozanof1868af2022-04-12 13:08:36 -04001811func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001812 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1813 // "current", it will append the VNDK version to the name suffix.
1814 var vndkVersion string
1815 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001816 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001817 if c.ProductSpecific() {
1818 // If the module is product specific with 'product_specific: true',
1819 // do not add a name suffix because it is a base module.
1820 return ""
1821 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001822 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001823 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001824 } else {
1825 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001826 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001827 }
1828 if vndkVersion == "current" {
1829 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1830 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001831 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001832 // add version suffix only if the module is using different vndk version than the
1833 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001834 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001835 }
1836 return nameSuffix
1837}
1838
Ivan Lozanof1868af2022-04-12 13:08:36 -04001839func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1840 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001841
1842 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001843 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001844 }
1845
Colin Cross127bb8b2020-12-16 16:46:01 -08001846 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001847 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001848 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1849 // added for product variant only when we have vendor and product variants with core
1850 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001851 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001852 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001853 subName += vendorPublicLibrarySuffix
1854 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001855 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1856 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001857 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001858 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001859 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001860 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001861 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001862 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001863 subName += RecoverySuffix
1864 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1865 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001866 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001867 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001868 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001869 } else if c.IsStubs() && c.IsSdkVariant() {
1870 // Public API surface (NDK)
1871 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1872 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001873 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001874
1875 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001876}
1877
Chris Parsonsf874e462022-05-10 13:50:12 -04001878var _ android.MixedBuildBuildable = (*Module)(nil)
1879
1880func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001881 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001882 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001883 // cc_library is a special case in bp2build; two targets are generated -- one for each
1884 // of the shared and static variants. The shared variant keeps the module name, but the
1885 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001886 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1887 } else {
1888 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001889 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001890 labelNoPrebuilt := bazelModuleLabel
1891 if c.IsPrebuilt() {
1892 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1893 }
1894 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001895}
1896
1897func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1898 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1899}
1900
Jingwen Chen3952a902022-12-12 12:20:58 +00001901// IsMixedBuildSupported returns true if the module should be analyzed by Bazel
Jingwen Chena485d092023-04-20 12:34:08 +00001902// in any of the --bazel-mode(s).
Chris Parsonsf874e462022-05-10 13:50:12 -04001903func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
Sam Delmericoef69d472023-04-18 17:32:43 -04001904 if !allEnabledSanitizersSupportedByBazel(c) {
1905 //TODO(b/278772861) support sanitizers in Bazel rules
Yu Liue4312402023-01-18 09:15:31 -08001906 return false
1907 }
Sam Delmericoef69d472023-04-18 17:32:43 -04001908 return c.bazelHandler != nil
1909}
1910
1911func allEnabledSanitizersSupportedByBazel(c *Module) bool {
1912 if c.sanitize == nil {
1913 return true
1914 }
Yu Liue4312402023-01-18 09:15:31 -08001915 sanitizeProps := &c.sanitize.Properties.SanitizeMutated
Sam Delmericoef69d472023-04-18 17:32:43 -04001916
1917 unsupportedSanitizers := []*bool{
1918 sanitizeProps.Safestack,
Sam Delmericoef69d472023-04-18 17:32:43 -04001919 sanitizeProps.Scudo,
1920 BoolPtr(len(c.sanitize.Properties.Sanitize.Recover) > 0),
1921 BoolPtr(c.sanitize.Properties.Sanitize.Blocklist != nil),
1922 }
1923 for _, san := range unsupportedSanitizers {
1924 if Bool(san) {
1925 return false
1926 }
1927 }
1928
1929 for _, san := range Sanitizers {
1930 if san == intOverflow {
1931 // TODO(b/261058727): enable mixed builds for all modules with UBSan
1932 // Currently we can only support ubsan when minimum runtime is used.
1933 ubsanEnabled := Bool(sanitizeProps.Integer_overflow) || len(sanitizeProps.Misc_undefined) > 0
1934 if ubsanEnabled && !c.MinimalRuntimeNeeded() {
1935 return false
1936 }
Yu Liu95497dc2023-05-25 11:15:07 -07001937 } else if san == cfi {
1938 continue
Sam Delmericoef69d472023-04-18 17:32:43 -04001939 } else if c.sanitize.isSanitizerEnabled(san) {
1940 return false
1941 }
1942 }
1943
1944 return true
Yu Liue4312402023-01-18 09:15:31 -08001945}
1946
1947func GetApexConfigKey(ctx android.BaseModuleContext) *android.ApexConfigKey {
1948 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1949 if !apexInfo.IsForPlatform() {
Yu Liubfb23622023-02-22 10:42:15 -08001950 if !ctx.Config().BazelContext.IsModuleDclaAllowed(ctx.Module().Name()) {
1951 return nil
1952 }
Yu Liue4312402023-01-18 09:15:31 -08001953 apexKey := android.ApexConfigKey{
1954 WithinApex: true,
1955 ApexSdkVersion: findApexSdkVersion(ctx, apexInfo).String(),
1956 }
1957 return &apexKey
1958 }
1959
1960 return nil
Chris Parsonsf874e462022-05-10 13:50:12 -04001961}
1962
1963func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
1964 bazelModuleLabel := c.getBazelModuleLabel(ctx)
Chris Parsonsf874e462022-05-10 13:50:12 -04001965 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
1966
1967 c.Properties.SubName = GetSubnameProperty(ctx, c)
1968 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1969 if !apexInfo.IsForPlatform() {
1970 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05001971 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001972
Chris Parsonsf874e462022-05-10 13:50:12 -04001973 c.makeLinkType = GetMakeLinkType(ctx, c)
1974
1975 mctx := &moduleContext{
1976 ModuleContext: ctx,
1977 moduleContextImpl: moduleContextImpl{
1978 mod: c,
1979 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05001980 }
Chris Parsonsf874e462022-05-10 13:50:12 -04001981 mctx.ctx = mctx
1982
Jingwen Chen3952a902022-12-12 12:20:58 +00001983 // TODO(b/244432500): Get the tradefed config from the bazel target instead
1984 // of generating it with Soong.
Chris Parsonsf874e462022-05-10 13:50:12 -04001985 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001986}
1987
Sam Delmerico75dbca22023-04-20 13:13:25 +00001988func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1989 ctx := &moduleContext{
1990 ModuleContext: actx,
1991 moduleContextImpl: moduleContextImpl{
1992 mod: c,
1993 },
1994 }
1995 ctx.ctx = ctx
1996 return ctx
1997}
1998
Spandan Das20fce2d2023-04-12 17:21:39 +00001999// TODO (b/277651159): Remove this allowlist
2000var (
2001 skipStubLibraryMultipleApexViolation = map[string]bool{
2002 "libclang_rt.asan": true,
2003 "libclang_rt.hwasan": true,
2004 // runtime apex
2005 "libc": true,
2006 "libc_hwasan": true,
2007 "libdl_android": true,
2008 "libm": true,
2009 "libdl": true,
2010 // art apex
2011 "libandroidio": true,
2012 "libdexfile": true,
2013 "libnativebridge": true,
2014 "libnativehelper": true,
2015 "libnativeloader": true,
2016 "libsigchain": true,
2017 }
2018)
2019
2020// Returns true if a stub library could be installed in multiple apexes
2021func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
2022 // If this is not an apex variant, no check necessary
2023 if !c.InAnyApex() {
2024 return false
2025 }
2026 // If this is not a stub library, no check necessary
2027 if !c.HasStubsVariants() {
2028 return false
2029 }
2030 // Skip the allowlist
2031 // Use BaseModuleName so that this matches prebuilts.
2032 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
2033 return false
2034 }
2035
2036 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
2037 // Stub libraries should not have more than one apex_available
2038 if len(aaWithoutTestApexes) > 1 {
2039 return true
2040 }
2041 // Stub libraries should not use the wildcard
2042 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
2043 return true
2044 }
2045 // Default: no violation
2046 return false
2047}
2048
Chris Parsons8d6e4332021-02-22 16:13:50 -05002049func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05002050 // Handle the case of a test module split by `test_per_src` mutator.
2051 //
2052 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
2053 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
2054 // module and return early, as this module does not produce an output file per se.
2055 if c.IsTestPerSrcAllTestsVariation() {
2056 c.outputFile = android.OptionalPath{}
2057 return
2058 }
2059
Ivan Lozanof1868af2022-04-12 13:08:36 -04002060 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002061 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2062 if !apexInfo.IsForPlatform() {
2063 c.hideApexVariantFromMake = true
2064 }
2065
Chris Parsonseefc9e62021-04-02 17:36:47 -04002066 c.makeLinkType = GetMakeLinkType(actx, c)
2067
Sam Delmerico75dbca22023-04-20 13:13:25 +00002068 ctx := moduleContextFromAndroidModuleContext(actx, c)
Colin Crossca860ac2016-01-04 14:34:37 -08002069
Colin Crossf18e1102017-11-16 14:33:08 -08002070 deps := c.depsToPaths(ctx)
2071 if ctx.Failed() {
2072 return
2073 }
2074
Spandan Das20fce2d2023-04-12 17:21:39 +00002075 if c.stubLibraryMultipleApexViolation(actx) {
2076 actx.PropertyErrorf("apex_available",
2077 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
2078 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002079 if c.Properties.Clang != nil && *c.Properties.Clang == false {
2080 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00002081 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
2082 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002083 }
2084
Colin Crossca860ac2016-01-04 14:34:37 -08002085 flags := Flags{
2086 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002087 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002088 }
Colin Crossca860ac2016-01-04 14:34:37 -08002089 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002090 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002091 }
2092 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002093 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002094 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002095 if c.stl != nil {
2096 flags = c.stl.flags(ctx, flags)
2097 }
Colin Cross16b23492016-01-06 14:41:07 -08002098 if c.sanitize != nil {
2099 flags = c.sanitize.flags(ctx, flags)
2100 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002101 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002102 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002103 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002104 if c.fuzzer != nil {
2105 flags = c.fuzzer.flags(ctx, flags)
2106 }
Stephen Craneba090d12017-05-09 15:44:35 -07002107 if c.lto != nil {
2108 flags = c.lto.flags(ctx, flags)
2109 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002110 if c.afdo != nil {
2111 flags = c.afdo.flags(ctx, flags)
2112 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002113 if c.pgo != nil {
2114 flags = c.pgo.flags(ctx, flags)
2115 }
Colin Crossca860ac2016-01-04 14:34:37 -08002116 for _, feature := range c.features {
2117 flags = feature.flags(ctx, flags)
2118 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002119 if ctx.Failed() {
2120 return
2121 }
2122
Colin Cross4af21ed2019-11-04 09:37:55 -08002123 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2124 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2125 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002126
Colin Cross4af21ed2019-11-04 09:37:55 -08002127 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002128
2129 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002130 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002131 }
2132 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002133 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002134 }
2135
Colin Cross3e5e7782022-06-17 22:17:05 +00002136 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2137
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002138 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002139 // We need access to all the flags seen by a source file.
2140 if c.sabi != nil {
2141 flags = c.sabi.flags(ctx, flags)
2142 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002143
Colin Cross4af21ed2019-11-04 09:37:55 -08002144 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002145
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002146 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002147 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002148 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002149 if ctx.Failed() {
2150 return
2151 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002152 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002153 c.objFiles = objs.objFiles
2154 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002155 }
2156
Colin Crossca860ac2016-01-04 14:34:37 -08002157 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002158 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002159 if ctx.Failed() {
2160 return
2161 }
Colin Cross635c3b02016-05-18 15:37:25 -07002162 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002163
Chris Parsons94a0bba2021-06-04 15:03:47 -04002164 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002165
Jose Galmes6f843bc2020-12-11 13:36:29 -08002166 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2167 // RECOVERY_SNAPSHOT_VERSION is current.
2168 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002169 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002170 i.collectHeadersForSnapshot(ctx)
2171 }
2172 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002173 }
Colin Cross5049f022015-03-18 13:28:46 -07002174
Chris Parsons94a0bba2021-06-04 15:03:47 -04002175 c.maybeInstall(ctx, apexInfo)
2176}
2177
2178func (c *Module) maybeUnhideFromMake() {
2179 // If a lib is directly included in any of the APEXes or is not available to the
2180 // platform (which is often the case when the stub is provided as a prebuilt),
2181 // unhide the stubs variant having the latest version gets visible to make. In
2182 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2183 // force anything in the make world to link against the stubs library. (unless it
2184 // is explicitly referenced via .bootstrap suffix or the module is marked with
2185 // 'bootstrap: true').
2186 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2187 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2188 c.IsStubs() && !c.InVendorRamdisk() {
2189 c.Properties.HideFromMake = false // unhide
2190 // Note: this is still non-installable
2191 }
2192}
2193
Jingwen Chen3952a902022-12-12 12:20:58 +00002194// maybeInstall is called at the end of both GenerateAndroidBuildActions and
2195// ProcessBazelQueryResponse to run the install hooks for installable modules,
2196// like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002197func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002198 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002199 // If the module has been specifically configure to not be installed then
2200 // hide from make as otherwise it will break when running inside make
2201 // as the output path to install will not be specified. Not all uninstallable
2202 // modules can be hidden from make as some are needed for resolving make side
2203 // dependencies.
2204 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002205 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002206 c.SkipInstall()
2207 }
2208
2209 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2210 // to allow using the outputs in a genrule.
2211 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002212 c.installer.install(ctx, c.outputFile.Path())
2213 if ctx.Failed() {
2214 return
Colin Crossca860ac2016-01-04 14:34:37 -08002215 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002216 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002217}
2218
Sam Delmerico5fb794a2023-01-27 16:01:37 -05002219func (c *Module) setAndroidMkVariablesFromCquery(info cquery.CcAndroidMkInfo) {
2220 c.Properties.AndroidMkSharedLibs = info.LocalSharedLibs
2221 c.Properties.AndroidMkStaticLibs = info.LocalStaticLibs
2222 c.Properties.AndroidMkWholeStaticLibs = info.LocalWholeStaticLibs
2223}
2224
Colin Cross0ea8ba82019-06-06 14:33:29 -07002225func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002226 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002227 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002228 }
Colin Crossca860ac2016-01-04 14:34:37 -08002229 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002230}
2231
Colin Crossca860ac2016-01-04 14:34:37 -08002232func (c *Module) begin(ctx BaseModuleContext) {
2233 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002234 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002235 }
Colin Crossca860ac2016-01-04 14:34:37 -08002236 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002237 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002238 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002239 if c.stl != nil {
2240 c.stl.begin(ctx)
2241 }
Colin Cross16b23492016-01-06 14:41:07 -08002242 if c.sanitize != nil {
2243 c.sanitize.begin(ctx)
2244 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002245 if c.coverage != nil {
2246 c.coverage.begin(ctx)
2247 }
Stephen Craneba090d12017-05-09 15:44:35 -07002248 if c.lto != nil {
2249 c.lto.begin(ctx)
2250 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002251 if c.pgo != nil {
2252 c.pgo.begin(ctx)
2253 }
Dan Albert92fe7402020-07-15 13:33:30 -07002254 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002255 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002256 if err != nil {
2257 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002258 c.Properties.Sdk_version = nil
2259 } else {
2260 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002261 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002262 }
Colin Crossca860ac2016-01-04 14:34:37 -08002263}
2264
Colin Cross37047f12016-12-13 17:06:13 -08002265func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002266 deps := Deps{}
2267
2268 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002269 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002270 }
2271 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002272 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002273 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002274 if c.stl != nil {
2275 deps = c.stl.deps(ctx, deps)
2276 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002277 if c.coverage != nil {
2278 deps = c.coverage.deps(ctx, deps)
2279 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002280
Colin Crossb6715442017-10-24 11:13:31 -07002281 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2282 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2283 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2284 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2285 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2286 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002287 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002288
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002289 for _, lib := range deps.ReexportSharedLibHeaders {
2290 if !inList(lib, deps.SharedLibs) {
2291 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2292 }
2293 }
2294
2295 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002296 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2297 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 -07002298 }
2299 }
2300
Colin Cross5950f382016-12-13 12:50:57 -08002301 for _, lib := range deps.ReexportHeaderLibHeaders {
2302 if !inList(lib, deps.HeaderLibs) {
2303 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2304 }
2305 }
2306
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002307 for _, gen := range deps.ReexportGeneratedHeaders {
2308 if !inList(gen, deps.GeneratedHeaders) {
2309 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2310 }
2311 }
2312
Colin Crossc99deeb2016-04-11 15:06:20 -07002313 return deps
2314}
2315
Dan Albert7e9d2952016-08-04 13:02:36 -07002316func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002317 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002318 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002319 moduleContextImpl: moduleContextImpl{
2320 mod: c,
2321 },
2322 }
2323 ctx.ctx = ctx
2324
Vinh Tran44cb78c2023-03-09 22:07:19 -05002325 if !actx.Host() || !ctx.static() || ctx.staticBinary() {
2326 c.afdo.addDep(ctx, actx)
2327 }
2328
Colin Crossca860ac2016-01-04 14:34:37 -08002329 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002330}
2331
Jiyong Park7ed9de32018-10-15 22:25:07 +09002332// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002333func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002334 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2335 version := name[sharp+1:]
2336 libname := name[:sharp]
2337 return libname, version
2338 }
2339 return name, ""
2340}
2341
Dan Albert92fe7402020-07-15 13:33:30 -07002342func GetCrtVariations(ctx android.BottomUpMutatorContext,
2343 m LinkableInterface) []blueprint.Variation {
2344 if ctx.Os() != android.Android {
2345 return nil
2346 }
2347 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002348 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2349 minSdkVersion := m.MinSdkVersion()
2350 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2351 minSdkVersion = m.SdkVersion()
2352 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002353 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2354 if err != nil {
2355 ctx.PropertyErrorf("min_sdk_version", err.Error())
2356 }
Colin Cross363ec762023-01-13 13:45:14 -08002357
2358 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002359 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002360 if apiLevel.LessThan(minApiForArch) {
2361 apiLevel = minApiForArch
2362 }
2363
Dan Albert92fe7402020-07-15 13:33:30 -07002364 return []blueprint.Variation{
2365 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002366 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002367 }
2368 }
2369 return []blueprint.Variation{
2370 {Mutator: "sdk", Variation: ""},
2371 }
2372}
2373
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002374func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2375 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002376
2377 variations = append([]blueprint.Variation(nil), variations...)
2378
Liz Kammer23942242022-04-08 15:41:00 -04002379 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002380 // Version is explicitly specified. i.e. libFoo#30
2381 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002382 if tag, ok := depTag.(libraryDependencyTag); ok {
2383 tag.explicitlyVersioned = true
2384 } else {
2385 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2386 }
Colin Crosse7257d22020-09-24 09:56:18 -07002387 }
Colin Crosse7257d22020-09-24 09:56:18 -07002388
Colin Cross0de8a1e2020-09-18 14:15:30 -07002389 if far {
2390 ctx.AddFarVariationDependencies(variations, depTag, name)
2391 } else {
2392 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002393 }
2394}
2395
Kiyoung Kim487689e2022-07-26 09:48:22 +09002396func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2397 apiImportInfo := multitree.ApiImportInfo{}
2398
2399 if c.Device() {
2400 var apiImportModule []blueprint.Module
2401 if actx.OtherModuleExists("api_imports") {
2402 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2403 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2404 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2405 apiImportInfo = apiInfo
2406 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2407 }
2408 }
2409 }
2410
2411 return apiImportInfo
2412}
2413
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002414func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002415 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002416 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002417 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002418 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2419 // between the modules in the snapshot and the snapshot itself.
2420 var snapshotModule []blueprint.Module
2421 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2422 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2423 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2424 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2425 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002426 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002427 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2428 *snapshotInfo = &snapshot
2429 // republish the snapshot for use in later mutators on this module
2430 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002431 }
2432 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002433 if *snapshotInfo == nil {
2434 *snapshotInfo = &SnapshotInfo{}
2435 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002436 return **snapshotInfo
2437}
2438
Kiyoung Kim487689e2022-07-26 09:48:22 +09002439func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2440 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002441 return snapshot
2442 }
2443
2444 return lib
2445}
2446
2447// RewriteLibs takes a list of names of shared libraries and scans it for three types
2448// of names:
2449//
2450// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002451//
2452// For each of these, it adds the name of the prebuilt module (which will be in
2453// prebuilts/ndk) to the list of nonvariant libs.
2454//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002455// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002456//
2457// For each of these, it adds the name of the ndk_library module to the list of
2458// variant libs.
2459//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002460// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002461//
2462// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002463//
2464// The caller can then know to add the variantLibs dependencies differently from the
2465// nonvariantLibs
2466func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2467 variantLibs = []string{}
2468
2469 nonvariantLibs = []string{}
2470 for _, entry := range list {
2471 // strip #version suffix out
2472 name, _ := StubsLibNameAndVersion(entry)
2473 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002474 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002475 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2476 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2477 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002478 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002479 } else {
2480 // put name#version back
2481 nonvariantLibs = append(nonvariantLibs, entry)
2482 }
2483 }
2484 return nonvariantLibs, variantLibs
2485}
2486
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002487func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2488 nonVariantLibs := []string{}
2489 variantLibs := []string{}
2490
2491 for _, lib := range libs {
2492 replaceLibName := GetReplaceModuleName(lib, replaceList)
2493 if replaceLibName == lib {
2494 // Do not handle any libs which are not in API imports
2495 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2496 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2497 variantLibs = append(variantLibs, replaceLibName)
2498 } else {
2499 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2500 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002501 }
2502
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002503 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002504}
2505
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002506func (c *Module) shouldUseApiSurface() bool {
2507 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2508 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2509 // LLNDK Variant
2510 return true
2511 }
2512
2513 if c.Properties.IsSdkVariant {
2514 // NDK Variant
2515 return true
2516 }
2517
2518 if c.isImportedApiLibrary() {
2519 // API Library should depend on API headers
2520 return true
2521 }
2522 }
2523
2524 return false
2525}
2526
Colin Cross1e676be2016-10-12 14:38:15 -07002527func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002528 if !c.Enabled() {
2529 return
2530 }
2531
Colin Cross37047f12016-12-13 17:06:13 -08002532 ctx := &depsContext{
2533 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002534 moduleContextImpl: moduleContextImpl{
2535 mod: c,
2536 },
2537 }
2538 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002539
Colin Crossc99deeb2016-04-11 15:06:20 -07002540 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002541 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002542
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002543 apiNdkLibs := []string{}
2544 apiLateNdkLibs := []string{}
2545
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002546 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002547 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2548 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2549 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2550 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2551 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002552 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002553
Yo Chiang219968c2020-09-22 18:45:04 +08002554 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2555
Colin Crosse0edaf92021-01-11 17:31:17 -08002556 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002557
Dan Albert914449f2016-06-17 16:45:24 -07002558 variantNdkLibs := []string{}
2559 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002560 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002561 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2562 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2563 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002564
2565 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002566 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002567 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002568 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002569
Colin Cross32ec36c2016-12-15 07:39:51 -08002570 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002571 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002572 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002573 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002574 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002575
Kiyoung Kim51279d32022-08-24 14:10:46 +09002576 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002577 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002578 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2579 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002580 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002581
Spandan Das73bcafc2022-08-18 23:26:00 +00002582 if c.isNDKStubLibrary() {
2583 // ndk_headers do not have any variations
2584 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002585 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002586 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002587 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002588 } else {
2589 actx.AddVariationDependencies(nil, depTag, lib)
2590 }
2591 }
2592
Dan Albertf1d14c72020-07-30 14:32:55 -07002593 if c.isNDKStubLibrary() {
2594 // NDK stubs depend on their implementation because the ABI dumps are
2595 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002596
Spandan Das8b08aea2023-03-14 19:29:34 +00002597 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2598 c.ImageVariation(),
2599 blueprint.Variation{Mutator: "link", Variation: "shared"},
2600 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002601 }
2602
Jiyong Park5d1598f2019-02-25 22:14:17 +09002603 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002604 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002605
Kiyoung Kim487689e2022-07-26 09:48:22 +09002606 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002607
Jiyong Park5d1598f2019-02-25 22:14:17 +09002608 actx.AddVariationDependencies([]blueprint.Variation{
2609 {Mutator: "link", Variation: "static"},
2610 }, depTag, lib)
2611 }
2612
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002613 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002614 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002615 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002616 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002617 }
Jiyong Parke3867542020-12-03 17:28:25 +09002618 if inList(lib, deps.ExcludeLibsForApex) {
2619 depTag.excludeInApex = true
2620 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002621
Kiyoung Kim487689e2022-07-26 09:48:22 +09002622 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002623
Dan Willemsen59339a22018-07-22 21:18:45 -07002624 actx.AddVariationDependencies([]blueprint.Variation{
2625 {Mutator: "link", Variation: "static"},
2626 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002627 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002628
Jooyung Han75568392020-03-20 04:29:24 +09002629 // staticUnwinderDep is treated as staticDep for Q apexes
2630 // so that native libraries/binaries are linked with static unwinder
2631 // because Q libc doesn't have unwinder APIs
2632 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002633 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002634 actx.AddVariationDependencies([]blueprint.Variation{
2635 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002636 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002637 }
2638
Jiyong Park7ed9de32018-10-15 22:25:07 +09002639 // shared lib names without the #version suffix
2640 var sharedLibNames []string
2641
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002642 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002643 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002644 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002645 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002646 }
Jiyong Parke3867542020-12-03 17:28:25 +09002647 if inList(lib, deps.ExcludeLibsForApex) {
2648 depTag.excludeInApex = true
2649 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002650
Jiyong Park73c54ee2019-10-22 20:31:18 +09002651 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002652 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2653 name = apiLibraryName
2654 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002655 sharedLibNames = append(sharedLibNames, name)
2656
Colin Crosse7257d22020-09-24 09:56:18 -07002657 variations := []blueprint.Variation{
2658 {Mutator: "link", Variation: "shared"},
2659 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002660
2661 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2662 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2663 }
2664
2665 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2666 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2667 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002668 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002669
Colin Crossfe9acfe2021-06-14 16:13:03 -07002670 for _, lib := range deps.LateStaticLibs {
2671 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2672 actx.AddVariationDependencies([]blueprint.Variation{
2673 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002674 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002675 }
2676
Colin Cross3e5e7782022-06-17 22:17:05 +00002677 for _, lib := range deps.UnexportedStaticLibs {
2678 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2679 actx.AddVariationDependencies([]blueprint.Variation{
2680 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002681 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002682 }
2683
Jiyong Park7ed9de32018-10-15 22:25:07 +09002684 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002685 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002686 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2687 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2688 // linking against both the stubs lib and the non-stubs lib at the same time.
2689 continue
2690 }
Colin Cross6e511a92020-07-27 21:26:48 -07002691 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002692 variations := []blueprint.Variation{
2693 {Mutator: "link", Variation: "shared"},
2694 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002695 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002696 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002697
Dan Willemsen59339a22018-07-22 21:18:45 -07002698 actx.AddVariationDependencies([]blueprint.Variation{
2699 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002700 }, dataLibDepTag, deps.DataLibs...)
2701
Colin Crossc8caa062021-09-24 16:50:14 -07002702 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2703
Chris Parsons79d66a52020-06-05 17:26:16 -04002704 actx.AddVariationDependencies([]blueprint.Variation{
2705 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002706 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002707
Colin Cross68861832016-07-08 10:41:41 -07002708 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002709
2710 for _, gen := range deps.GeneratedHeaders {
2711 depTag := genHeaderDepTag
2712 if inList(gen, deps.ReexportGeneratedHeaders) {
2713 depTag = genHeaderExportDepTag
2714 }
2715 actx.AddDependency(c, depTag, gen)
2716 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002717
Dan Albert92fe7402020-07-15 13:33:30 -07002718 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002719 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002720 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002721 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002722 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002723 }
Colin Crossc465efd2021-06-11 18:00:04 -07002724 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002725 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002726 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002727 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002728 if deps.DynamicLinker != "" {
2729 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002730 }
Dan Albert914449f2016-06-17 16:45:24 -07002731
2732 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002733
2734 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002735 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002736 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002737 {Mutator: "link", Variation: "shared"},
2738 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002739 actx.AddVariationDependencies([]blueprint.Variation{
2740 {Mutator: "version", Variation: version},
2741 {Mutator: "link", Variation: "shared"},
2742 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002743
2744 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002745 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002746 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002747 {Mutator: "link", Variation: "shared"},
2748 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002749 actx.AddVariationDependencies([]blueprint.Variation{
2750 {Mutator: "version", Variation: version},
2751 {Mutator: "link", Variation: "shared"},
2752 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002753
2754 if vndkdep := c.vndkdep; vndkdep != nil {
2755 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002756 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002757 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002758 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002759 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002760 }
2761 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002762
Vinh Tran367d89d2023-04-28 11:21:25 -04002763 if len(deps.AidlLibs) > 0 {
2764 actx.AddDependency(
2765 c,
2766 aidlLibraryTag,
2767 deps.AidlLibs...,
2768 )
2769 }
2770
Kiyoung Kimee58c932022-10-25 22:59:41 +09002771 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002772}
Colin Cross21b9a242015-03-24 14:15:58 -07002773
Colin Crosse40b4ea2018-10-02 22:25:58 -07002774func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002775 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2776 c.beginMutator(ctx)
2777 }
2778}
2779
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002780// Whether a module can link to another module, taking into
2781// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002782func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002783 tag blueprint.DependencyTag) {
2784
2785 switch t := tag.(type) {
2786 case dependencyTag:
2787 if t != vndkExtDepTag {
2788 return
2789 }
2790 case libraryDependencyTag:
2791 default:
2792 return
2793 }
2794
Ivan Lozanof9e21722020-12-02 09:00:51 -05002795 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002796 // Host code is not restricted
2797 return
2798 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002799
2800 // VNDK is cc.Module supported only for now.
2801 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002802 // Though allowed dependency is limited by the image mutator,
2803 // each vendor and product module needs to check link-type
2804 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002805 if ccTo, ok := to.(*Module); ok {
2806 if ccFrom.vndkdep != nil {
2807 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2808 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002809 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002810 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002811 }
2812 return
2813 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002814 // TODO(b/244244438) : Remove this once all variants are implemented
2815 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2816 return
2817 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002818 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002819 // Platform code can link to anything
2820 return
2821 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002822 if from.InRamdisk() {
2823 // Ramdisk code is not NDK
2824 return
2825 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002826 if from.InVendorRamdisk() {
2827 // Vendor ramdisk code is not NDK
2828 return
2829 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002830 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002831 // Recovery code is not NDK
2832 return
2833 }
Colin Cross31076b32020-10-23 17:22:06 -07002834 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002835 if c.NdkPrebuiltStl() {
2836 // These are allowed, but they don't set sdk_version
2837 return
2838 }
2839 if c.StubDecorator() {
2840 // These aren't real libraries, but are the stub shared libraries that are included in
2841 // the NDK.
2842 return
2843 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002844 if c.isImportedApiLibrary() {
2845 // Imported library from the API surface is a stub library built against interface definition.
2846 return
2847 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002848 }
Logan Chien834b9a62019-01-14 15:39:03 +08002849
Ivan Lozano52767be2019-10-18 14:49:46 -07002850 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002851 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2852 // to link to libc++ (non-NDK and without sdk_version).
2853 return
2854 }
2855
Ivan Lozano52767be2019-10-18 14:49:46 -07002856 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002857 // NDK code linking to platform code is never okay.
2858 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002859 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002860 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002861 }
2862
2863 // At this point we know we have two NDK libraries, but we need to
2864 // check that we're not linking against anything built against a higher
2865 // API level, as it is only valid to link against older or equivalent
2866 // APIs.
2867
Inseob Kim01a28722018-04-11 09:48:45 +09002868 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002869 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002870 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002871 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002872 // Current can't be linked against by anything else.
2873 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002874 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002875 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002876 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002877 if err != nil {
2878 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002879 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002880 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002881 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002882 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002883 if err != nil {
2884 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002885 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002886 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002887 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002888
Inseob Kim01a28722018-04-11 09:48:45 +09002889 if toApi > fromApi {
2890 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002891 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002892 }
2893 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002894 }
Dan Albert202fe492017-12-15 13:56:59 -08002895
2896 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002897 fromStl := from.SelectedStl()
2898 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002899 if fromStl == "" || toStl == "" {
2900 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002901 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002902 // We can be permissive with the system "STL" since it is only the C++
2903 // ABI layer, but in the future we should make sure that everyone is
2904 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002905 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002906 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002907 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2908 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002909 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002910}
2911
Jooyung Han479ca172020-10-19 18:51:07 +09002912func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2913 if c, ok := ctx.Module().(*Module); ok {
2914 ctx.VisitDirectDeps(func(dep android.Module) {
2915 depTag := ctx.OtherModuleDependencyTag(dep)
2916 ccDep, ok := dep.(LinkableInterface)
2917 if ok {
2918 checkLinkType(ctx, c, ccDep, depTag)
2919 }
2920 })
2921 }
2922}
2923
Jiyong Park5fb8c102018-04-09 12:03:06 +09002924// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002925// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2926// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002927// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002928func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2929 check := func(child, parent android.Module) bool {
2930 to, ok := child.(*Module)
2931 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002932 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002933 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002934
Jooyung Hana70f0672019-01-18 15:20:43 +09002935 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2936 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002937 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002938
Jiyong Park0474e1f2021-01-14 14:26:06 +09002939 // These dependencies are not excercised at runtime. Tracking these will give us
2940 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002941 depTag := ctx.OtherModuleDependencyTag(child)
2942 if IsHeaderDepTag(depTag) {
2943 return false
2944 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002945 if depTag == staticVariantTag {
2946 return false
2947 }
2948 if depTag == stubImplDepTag {
2949 return false
2950 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002951
Justin Yun63e9ec72020-10-29 16:49:43 +09002952 // Even if target lib has no vendor variant, keep checking dependency
2953 // graph in case it depends on vendor_available or product_available
2954 // but not double_loadable transtively.
2955 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002956 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002957 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002958
Jiyong Park0474e1f2021-01-14 14:26:06 +09002959 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2960 // one.
2961 if Bool(to.VendorProperties.Double_loadable) {
2962 return true
2963 }
2964
Ivan Lozanod7586b62021-04-01 09:49:36 -04002965 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002966 return false
2967 }
2968
Jooyung Hana70f0672019-01-18 15:20:43 +09002969 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2970 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002971 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002972 return false
2973 }
2974 if module, ok := ctx.Module().(*Module); ok {
2975 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002976 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002977 ctx.WalkDeps(check)
2978 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002979 }
2980 }
2981}
2982
Yu Liue4312402023-01-18 09:15:31 -08002983func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2984 // For the dependency from platform to apex, use the latest stubs
2985 apexSdkVersion := android.FutureApiLevel
2986 if !apexInfo.IsForPlatform() {
2987 apexSdkVersion = apexInfo.MinSdkVersion
2988 }
2989
2990 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2991 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2992 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2993 // (b/144430859)
2994 apexSdkVersion = android.FutureApiLevel
2995 }
2996
2997 return apexSdkVersion
2998}
2999
Colin Crossc99deeb2016-04-11 15:06:20 -07003000// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07003001func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08003002 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08003003
Colin Cross0de8a1e2020-09-18 14:15:30 -07003004 var directStaticDeps []StaticLibraryInfo
3005 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07003006
Colin Cross0de8a1e2020-09-18 14:15:30 -07003007 reexportExporter := func(exporter FlagExporterInfo) {
3008 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
3009 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
3010 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
3011 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
3012 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09003013 }
3014
Colin Cross56a83212020-09-15 18:30:11 -07003015 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Yu Liue4312402023-01-18 09:15:31 -08003016 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09003017
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003018 skipModuleList := map[string]bool{}
3019
3020 var apiImportInfo multitree.ApiImportInfo
3021 hasApiImportInfo := false
3022
3023 ctx.VisitDirectDeps(func(dep android.Module) {
3024 if dep.Name() == "api_imports" {
3025 apiImportInfo = ctx.OtherModuleProvider(dep, multitree.ApiImportsProvider).(multitree.ApiImportInfo)
3026 hasApiImportInfo = true
3027 }
3028 })
3029
3030 if hasApiImportInfo {
3031 targetStubModuleList := map[string]string{}
3032 targetOrigModuleList := map[string]string{}
3033
3034 // Search for dependency which both original module and API imported library with APEX stub exists
3035 ctx.VisitDirectDeps(func(dep android.Module) {
3036 depName := ctx.OtherModuleName(dep)
3037 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
3038 targetStubModuleList[apiLibrary] = depName
3039 }
3040 })
3041 ctx.VisitDirectDeps(func(dep android.Module) {
3042 depName := ctx.OtherModuleName(dep)
3043 if origLibrary, ok := targetStubModuleList[depName]; ok {
3044 targetOrigModuleList[origLibrary] = depName
3045 }
3046 })
3047
3048 // Decide which library should be used between original and API imported library
3049 ctx.VisitDirectDeps(func(dep android.Module) {
3050 depName := ctx.OtherModuleName(dep)
3051 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00003052 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003053 skipModuleList[depName] = true
3054 } else {
3055 skipModuleList[apiLibrary] = true
3056 }
3057 }
3058 })
3059 }
3060
Colin Crossd11fcda2017-10-23 17:59:01 -07003061 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003062 depName := ctx.OtherModuleName(dep)
3063 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07003064
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003065 if _, ok := skipModuleList[depName]; ok {
3066 // skip this module because original module or API imported module matching with this should be used instead.
3067 return
3068 }
3069
Dan Willemsen47450072021-10-19 20:24:49 -07003070 if depTag == android.DarwinUniversalVariantTag {
3071 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3072 return
3073 }
3074
Vinh Tran367d89d2023-04-28 11:21:25 -04003075 if depTag == aidlLibraryTag {
3076 if ctx.OtherModuleHasProvider(dep, aidl_library.AidlLibraryProvider) {
3077 depPaths.AidlLibraryInfos = append(
3078 depPaths.AidlLibraryInfos,
3079 ctx.OtherModuleProvider(
3080 dep,
3081 aidl_library.AidlLibraryProvider).(aidl_library.AidlLibraryInfo),
3082 )
3083 }
3084 }
3085
Ivan Lozano52767be2019-10-18 14:49:46 -07003086 ccDep, ok := dep.(LinkableInterface)
3087 if !ok {
3088
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003089 // handling for a few module types that aren't cc Module but that are also supported
3090 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003091 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003092 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003093 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3094 genRule.GeneratedSourceFiles()...)
3095 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003096 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003097 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003098 // Support exported headers from a generated_sources dependency
3099 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003100 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003101 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003102 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003103 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003104 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003105 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003106 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003107 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003108 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3109 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003110 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003111 // 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 +09003112 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003113
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003114 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003115 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003116 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003117 }
Colin Crosscef792e2021-06-11 18:01:26 -07003118 case CrtBeginDepTag:
3119 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3120 case CrtEndDepTag:
3121 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003122 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003123 return
3124 }
3125
Colin Crossfe17f6f2019-03-28 19:30:56 -07003126 if depTag == android.ProtoPluginDepTag {
3127 return
3128 }
3129
Colin Crossd11fcda2017-10-23 17:59:01 -07003130 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003131 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3132 return
3133 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003134 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003135 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3136 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003137 return
3138 }
3139
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003140 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003141 // Skip reused objects for stub libraries, they use their own stub object file instead.
3142 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3143 // version mutator, so the stubs variant is created from the shared variant that
3144 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003145 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07003146 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3147 objs := staticAnalogue.ReuseObjects
3148 depPaths.Objs = depPaths.Objs.Append(objs)
3149 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3150 reexportExporter(depExporterInfo)
3151 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003152 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003153 }
3154
Colin Cross6e511a92020-07-27 21:26:48 -07003155 linkFile := ccDep.OutputFile()
3156
3157 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3158 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003159 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003160 return
3161 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003162
Jiyong Parke3867542020-12-03 17:28:25 +09003163 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3164 return
3165 }
3166
Colin Cross0de8a1e2020-09-18 14:15:30 -07003167 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07003168
Colin Cross6e511a92020-07-27 21:26:48 -07003169 var ptr *android.Paths
3170 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003171
Colin Cross6e511a92020-07-27 21:26:48 -07003172 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003173
Colin Cross6e511a92020-07-27 21:26:48 -07003174 switch {
3175 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08003176 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
3177 if !ctx.Config().AllowMissingDependencies() {
3178 ctx.ModuleErrorf("module %q is not a header library", depName)
3179 } else {
3180 ctx.AddMissingDependencies([]string{depName})
3181 }
3182 return
3183 }
Colin Cross6e511a92020-07-27 21:26:48 -07003184 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003185 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
3186 if !ctx.Config().AllowMissingDependencies() {
3187 ctx.ModuleErrorf("module %q is not a shared library", depName)
3188 } else {
3189 ctx.AddMissingDependencies([]string{depName})
3190 }
3191 return
3192 }
Jiyong Parke3867542020-12-03 17:28:25 +09003193
Jiyong Park7d55b612021-06-11 17:22:09 +09003194 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3195 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003196
Jiyong Park1ad8e162020-12-01 23:40:09 +09003197 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3198 // linkFile, depFile, and ptr.
3199 if c.IsStubs() {
3200 break
3201 }
3202
Colin Cross0de8a1e2020-09-18 14:15:30 -07003203 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3204 depFile = sharedLibraryInfo.TableOfContents
3205
Colin Cross6e511a92020-07-27 21:26:48 -07003206 ptr = &depPaths.SharedLibs
3207 switch libDepTag.Order {
3208 case earlyLibraryDependency:
3209 ptr = &depPaths.EarlySharedLibs
3210 depPtr = &depPaths.EarlySharedLibsDeps
3211 case normalLibraryDependency:
3212 ptr = &depPaths.SharedLibs
3213 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003214 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003215 case lateLibraryDependency:
3216 ptr = &depPaths.LateSharedLibs
3217 depPtr = &depPaths.LateSharedLibsDeps
3218 default:
3219 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003220 }
Colin Cross6e511a92020-07-27 21:26:48 -07003221 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003222 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
3223 if !ctx.Config().AllowMissingDependencies() {
3224 ctx.ModuleErrorf("module %q is not a static library", depName)
3225 } else {
3226 ctx.AddMissingDependencies([]string{depName})
3227 }
3228 return
3229 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003230
3231 // Stubs lib doesn't link to the static lib dependencies. Don't set
3232 // linkFile, depFile, and ptr.
3233 if c.IsStubs() {
3234 break
3235 }
3236
Colin Cross0de8a1e2020-09-18 14:15:30 -07003237 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3238 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003239 if libDepTag.wholeStatic {
3240 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003241 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3242 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003243 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003244 // This case normally catches prebuilt static
3245 // libraries, but it can also occur when
3246 // AllowMissingDependencies is on and the
3247 // dependencies has no sources of its own
3248 // but has a whole_static_libs dependency
3249 // on a missing library. We want to depend
3250 // on the .a file so that there is something
3251 // in the dependency tree that contains the
3252 // error rule for the missing transitive
3253 // dependency.
3254 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003255 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003256 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3257 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003258 } else {
3259 switch libDepTag.Order {
3260 case earlyLibraryDependency:
3261 panic(fmt.Errorf("early static libs not suppported"))
3262 case normalLibraryDependency:
3263 // static dependencies will be handled separately so they can be ordered
3264 // using transitive dependencies.
3265 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003266 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003267 case lateLibraryDependency:
3268 ptr = &depPaths.LateStaticLibs
3269 default:
3270 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003271 }
3272 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003273 if libDepTag.unexportedSymbols {
3274 depPaths.LdFlags = append(depPaths.LdFlags,
3275 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3276 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003277 }
3278
Colin Cross6e511a92020-07-27 21:26:48 -07003279 if libDepTag.static() && !libDepTag.wholeStatic {
3280 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3281 ctx.ModuleErrorf("module %q not a static library", depName)
3282 return
3283 }
Logan Chien43d34c32017-12-20 01:17:32 +08003284
Colin Cross6e511a92020-07-27 21:26:48 -07003285 // When combining coverage files for shared libraries and executables, coverage files
3286 // in static libraries act as if they were whole static libraries. The same goes for
3287 // source based Abi dump files.
3288 if c, ok := ccDep.(*Module); ok {
3289 staticLib := c.linker.(libraryInterface)
3290 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3291 staticLib.objs().coverageFiles...)
3292 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3293 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003294 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003295 // Handle non-CC modules here
3296 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003297 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003298 }
3299 }
3300
Colin Cross6e511a92020-07-27 21:26:48 -07003301 if ptr != nil {
3302 if !linkFile.Valid() {
3303 if !ctx.Config().AllowMissingDependencies() {
3304 ctx.ModuleErrorf("module %q missing output file", depName)
3305 } else {
3306 ctx.AddMissingDependencies([]string{depName})
3307 }
3308 return
3309 }
3310 *ptr = append(*ptr, linkFile.Path())
3311 }
3312
3313 if depPtr != nil {
3314 dep := depFile
3315 if !dep.Valid() {
3316 dep = linkFile
3317 }
3318 *depPtr = append(*depPtr, dep.Path())
3319 }
3320
Colin Cross0de8a1e2020-09-18 14:15:30 -07003321 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3322 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3323 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3324 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3325
3326 if libDepTag.reexportFlags {
3327 reexportExporter(depExporterInfo)
3328 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3329 // Re-exported shared library headers must be included as well since they can help us with type information
3330 // about template instantiations (instantiated from their headers).
3331 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3332 // scripts.
3333 c.sabi.Properties.ReexportedIncludes = append(
3334 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3335 }
3336
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003337 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003338 switch {
3339 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003340 c.Properties.AndroidMkHeaderLibs = append(
3341 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003342 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003343 if lib := moduleLibraryInterface(dep); lib != nil {
3344 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003345 // Add the dependency to the APEX(es) providing the library so that
3346 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003347 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003348 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003349 c.Properties.ApexesProvidingSharedLibs = append(
3350 c.Properties.ApexesProvidingSharedLibs, an)
3351 }
3352 }
3353 }
3354
3355 // Note: the order of libs in this list is not important because
3356 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003357 c.Properties.AndroidMkSharedLibs = append(
3358 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003359 // Record BaseLibName for snapshots.
3360 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003361 case libDepTag.static():
3362 if libDepTag.wholeStatic {
3363 c.Properties.AndroidMkWholeStaticLibs = append(
3364 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3365 } else {
3366 c.Properties.AndroidMkStaticLibs = append(
3367 c.Properties.AndroidMkStaticLibs, makeLibName)
3368 }
Justin Yun5e035862021-06-29 20:50:37 +09003369 // Record BaseLibName for snapshots.
3370 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003371 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003372 } else if !c.IsStubs() {
3373 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3374
Colin Cross6e511a92020-07-27 21:26:48 -07003375 switch depTag {
3376 case runtimeDepTag:
3377 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003378 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003379 // Record BaseLibName for snapshots.
3380 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003381 case objDepTag:
3382 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3383 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003384 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003385 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003386 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003387 case dynamicLinkerDepTag:
3388 depPaths.DynamicLinker = linkFile
3389 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003390 }
Colin Crossca860ac2016-01-04 14:34:37 -08003391 })
3392
Jeff Gaston294356f2017-09-27 17:05:30 -07003393 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003394 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3395 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3396 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003397
Colin Crossdd84e052017-05-17 13:44:16 -07003398 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003399 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003400 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3401 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003402 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003403 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3404 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003405 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003406 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003407 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003408
3409 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003410 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003411 }
Colin Crossdd84e052017-05-17 13:44:16 -07003412
Colin Crossca860ac2016-01-04 14:34:37 -08003413 return depPaths
3414}
3415
Spandan Das604f3762023-03-16 22:51:40 +00003416func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003417 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003418 thisModule, ok := ctx.Module().(android.ApexModule)
3419 if !ok {
3420 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3421 }
3422
3423 useVndk := false
3424 bootstrap := false
3425 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3426 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3427 } else {
3428 useVndk = linkable.UseVndk()
3429 bootstrap = linkable.Bootstrap()
3430 }
3431
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003432 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3433
3434 useStubs := false
3435
3436 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3437 if !apexInfo.IsForPlatform() {
3438 // For platform libraries, use current version of LLNDK
3439 // If this is for use_vendor apex we will apply the same rules
3440 // of apex sdk enforcement below to choose right version.
3441 useStubs = true
3442 }
3443 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3444 // If not building for APEX or the containing APEX allows the use of
3445 // platform APIs, use stubs only when it is from an APEX (and not from
3446 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3447 // bootstrap modules, always link to non-stub variant
3448 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3449
3450 isApexImportedApiLibrary := false
3451
3452 if cc, ok := dep.(*Module); ok {
3453 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3454 if apiLibrary.hasApexStubs() {
3455 isApexImportedApiLibrary = true
3456 }
3457 }
3458 }
3459
3460 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3461
3462 if useStubs {
3463 // Another exception: if this module is a test for an APEX, then
3464 // it is linked with the non-stub variant of a module in the APEX
3465 // as if this is part of the APEX.
3466 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3467 for _, apexContents := range testFor.ApexContents {
3468 if apexContents.DirectlyInApex(depName) {
3469 useStubs = false
3470 break
3471 }
3472 }
3473 }
3474 if useStubs {
3475 // Yet another exception: If this module and the dependency are
3476 // available to the same APEXes then skip stubs between their
3477 // platform variants. This complements the test_for case above,
3478 // which avoids the stubs on a direct APEX library dependency, by
3479 // avoiding stubs for indirect test dependencies as well.
3480 //
3481 // TODO(b/183882457): This doesn't work if the two libraries have
3482 // only partially overlapping apex_available. For that test_for
3483 // modules would need to be split into APEX variants and resolved
3484 // separately for each APEX they have access to.
3485 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3486 useStubs = false
3487 }
3488 }
3489 } else {
3490 // If building for APEX, use stubs when the parent is in any APEX that
3491 // the child is not in.
3492 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3493 }
3494
3495 return useStubs
3496}
3497
3498// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3499// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3500// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3501// has different level of updatability. For example, if a library foo in an APEX depends on a
3502// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3503// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3504// same APEX as foo, the non-stub variant of bar is used.
3505func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3506 depTag := ctx.OtherModuleDependencyTag(dep)
3507 libDepTag, ok := depTag.(libraryDependencyTag)
3508 if !ok || !libDepTag.shared() {
3509 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3510 }
3511
Jiyong Park7d55b612021-06-11 17:22:09 +09003512 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3513 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3514 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Jiyong Park7d55b612021-06-11 17:22:09 +09003515
3516 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003517 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003518 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003519 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3520 toUse := stubs[len(stubs)-1]
3521 sharedLibraryInfo = toUse.SharedLibraryInfo
3522 depExporterInfo = toUse.FlagExporterInfo
3523 }
3524 }
3525 return sharedLibraryInfo, depExporterInfo
3526}
3527
Colin Cross0de8a1e2020-09-18 14:15:30 -07003528// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3529// to match the topological order of the dependency tree, including any static analogues of
3530// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3531// of the transitive dependencies.
3532func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3533 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3534 var staticPaths android.Paths
3535 for _, staticDep := range staticDeps {
3536 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3537 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3538 }
3539 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003540 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3541 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003542 }
3543 }
3544 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3545
3546 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3547
3548 // reorder the dependencies based on transitive dependencies
3549 staticPaths = android.FirstUniquePaths(staticPaths)
3550 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3551
3552 if len(orderedStaticPaths) != len(staticPaths) {
3553 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3554 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3555 }
3556
3557 return orderedStaticPaths, transitiveStaticLibs
3558}
3559
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003560// BaseLibName trims known prefixes and suffixes
3561func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003562 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3563 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003564 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003565 return libName
3566}
3567
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003568func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003569 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003570 ccDepModule, _ := ccDep.(*Module)
3571 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003572 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003573
Justin Yuncbca3732021-02-03 19:24:13 +09003574 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003575 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003576 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003577 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003578
Ivan Lozanod1dec542021-05-26 15:33:11 -04003579 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003580 }
3581 }
3582
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003583 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3584 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003585 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3586 // core module instead.
3587 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003588 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003589 // The vendor and product modules in Make will have been renamed to not conflict with the
3590 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003591 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003592 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003593 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003594 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003595 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003596 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003597 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003598 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003599 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003600 } else {
3601 return libName
3602 }
3603}
3604
Colin Crossca860ac2016-01-04 14:34:37 -08003605func (c *Module) InstallInData() bool {
3606 if c.installer == nil {
3607 return false
3608 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003609 return c.installer.inData()
3610}
3611
3612func (c *Module) InstallInSanitizerDir() bool {
3613 if c.installer == nil {
3614 return false
3615 }
3616 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003617 return true
3618 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003619 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003620}
3621
Yifan Hong1b3348d2020-01-21 15:53:22 -08003622func (c *Module) InstallInRamdisk() bool {
3623 return c.InRamdisk()
3624}
3625
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003626func (c *Module) InstallInVendorRamdisk() bool {
3627 return c.InVendorRamdisk()
3628}
3629
Jiyong Parkf9332f12018-02-01 00:54:12 +09003630func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003631 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003632}
3633
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003634func (c *Module) MakeUninstallable() {
3635 if c.installer == nil {
3636 c.ModuleBase.MakeUninstallable()
3637 return
3638 }
3639 c.installer.makeUninstallable(c)
3640}
3641
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003642func (c *Module) HostToolPath() android.OptionalPath {
3643 if c.installer == nil {
3644 return android.OptionalPath{}
3645 }
3646 return c.installer.hostToolPath()
3647}
3648
Nan Zhangd4e641b2017-07-12 12:55:28 -07003649func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3650 return c.outputFile
3651}
3652
Colin Cross41955e82019-05-29 14:40:35 -07003653func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3654 switch tag {
3655 case "":
3656 if c.outputFile.Valid() {
3657 return android.Paths{c.outputFile.Path()}, nil
3658 }
3659 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003660 case "unstripped":
3661 if c.linker != nil {
3662 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3663 }
3664 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003665 default:
3666 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003667 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003668}
3669
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003670func (c *Module) static() bool {
3671 if static, ok := c.linker.(interface {
3672 static() bool
3673 }); ok {
3674 return static.static()
3675 }
3676 return false
3677}
3678
Jiyong Park379de2f2018-12-19 02:47:14 +09003679func (c *Module) staticBinary() bool {
3680 if static, ok := c.linker.(interface {
3681 staticBinary() bool
3682 }); ok {
3683 return static.staticBinary()
3684 }
3685 return false
3686}
3687
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003688func (c *Module) testBinary() bool {
3689 if test, ok := c.linker.(interface {
3690 testBinary() bool
3691 }); ok {
3692 return test.testBinary()
3693 }
3694 return false
3695}
3696
Jingwen Chen537242c2022-08-24 11:53:27 +00003697func (c *Module) testLibrary() bool {
3698 if test, ok := c.linker.(interface {
3699 testLibrary() bool
3700 }); ok {
3701 return test.testLibrary()
3702 }
3703 return false
3704}
3705
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003706func (c *Module) benchmarkBinary() bool {
3707 if b, ok := c.linker.(interface {
3708 benchmarkBinary() bool
3709 }); ok {
3710 return b.benchmarkBinary()
3711 }
3712 return false
3713}
3714
3715func (c *Module) fuzzBinary() bool {
3716 if f, ok := c.linker.(interface {
3717 fuzzBinary() bool
3718 }); ok {
3719 return f.fuzzBinary()
3720 }
3721 return false
3722}
3723
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003724// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3725func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003726 if h, ok := c.linker.(interface {
3727 header() bool
3728 }); ok {
3729 return h.header()
3730 }
3731 return false
3732}
3733
Ivan Lozanod7586b62021-04-01 09:49:36 -04003734func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003735 if b, ok := c.linker.(interface {
3736 binary() bool
3737 }); ok {
3738 return b.binary()
3739 }
3740 return false
3741}
3742
Justin Yun5e035862021-06-29 20:50:37 +09003743func (c *Module) StaticExecutable() bool {
3744 if b, ok := c.linker.(*binaryDecorator); ok {
3745 return b.static()
3746 }
3747 return false
3748}
3749
Ivan Lozanod7586b62021-04-01 09:49:36 -04003750func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003751 if o, ok := c.linker.(interface {
3752 object() bool
3753 }); ok {
3754 return o.object()
3755 }
3756 return false
3757}
3758
Ivan Lozanof9e21722020-12-02 09:00:51 -05003759func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003760 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003761 if c.IsLlndk() {
3762 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003763 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003764 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003765 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003766 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003767 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003768 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003769 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003770 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003771 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003772 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003773 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003774 return "native:product"
3775 }
Jooyung Han38002912019-05-16 04:01:54 +09003776 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003777 } else if c.InRamdisk() {
3778 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003779 } else if c.InVendorRamdisk() {
3780 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003781 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003782 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003783 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003784 return "native:ndk:none:none"
3785 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3786 //family, link := getNdkStlFamilyAndLinkType(c)
3787 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003788 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003789 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003790 } else {
3791 return "native:platform"
3792 }
3793}
3794
Jiyong Park9d452992018-10-03 00:38:19 +09003795// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003796// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003797func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003798 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003799 // Stub libs and prebuilt libs in a versioned SDK are not
3800 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003801 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003802 } else if _, ok := c.linker.(testPerSrc); ok {
3803 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003804 }
3805 return false
3806}
3807
Jiyong Parka90ca002019-10-07 15:47:24 +09003808func (c *Module) AvailableFor(what string) bool {
3809 if linker, ok := c.linker.(interface {
3810 availableFor(string) bool
3811 }); ok {
3812 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3813 } else {
3814 return c.ApexModuleBase.AvailableFor(what)
3815 }
3816}
3817
Jiyong Park62304bb2020-04-13 16:19:48 +09003818func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003819 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003820}
3821
Paul Duffin0cb37b92020-03-04 14:52:46 +00003822func (c *Module) EverInstallable() bool {
3823 return c.installer != nil &&
3824 // Check to see whether the module is actually ever installable.
3825 c.installer.everInstallable()
3826}
3827
Ivan Lozanod7586b62021-04-01 09:49:36 -04003828func (c *Module) PreventInstall() bool {
3829 return c.Properties.PreventInstall
3830}
3831
3832func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003833 if c.library != nil {
3834 if i := c.library.installable(); i != nil {
3835 return i
3836 }
3837 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003838 return c.Properties.Installable
3839}
3840
3841func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003842 ret := c.EverInstallable() &&
3843 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003844 proptools.BoolDefault(c.Installable(), true) &&
3845 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003846
3847 // The platform variant doesn't need further condition. Apex variants however might not
3848 // be installable because it will likely to be included in the APEX and won't appear
3849 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003850 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003851 return ret
3852 }
3853
3854 // Special case for modules that are configured to be installed to /data, which includes
3855 // test modules. For these modules, both APEX and non-APEX variants are considered as
3856 // installable. This is because even the APEX variants won't be included in the APEX, but
3857 // will anyway be installed to /data/*.
3858 // See b/146995717
3859 if c.InstallInData() {
3860 return ret
3861 }
3862
3863 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003864}
3865
Logan Chien41eabe62019-04-10 13:33:58 +08003866func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3867 if c.linker != nil {
3868 if library, ok := c.linker.(*libraryDecorator); ok {
3869 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3870 }
3871 }
3872}
3873
Jiyong Park45bf82e2020-12-15 22:29:02 +09003874var _ android.ApexModule = (*Module)(nil)
3875
3876// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003877func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003878 depTag := ctx.OtherModuleDependencyTag(dep)
3879 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3880
3881 if cc, ok := dep.(*Module); ok {
3882 if cc.HasStubsVariants() {
3883 if isLibDepTag && libDepTag.shared() {
3884 // dynamic dep to a stubs lib crosses APEX boundary
3885 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003886 }
Colin Cross6e511a92020-07-27 21:26:48 -07003887 if IsRuntimeDepTag(depTag) {
3888 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003889 return false
3890 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003891 }
Zhijun Heec285872021-04-24 10:47:08 -07003892 if cc.IsLlndk() {
3893 return false
3894 }
Colin Crossaac32222020-07-29 12:51:56 -07003895 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003896 // shared_lib dependency from a static lib is considered as crossing
3897 // the APEX boundary because the dependency doesn't actually is
3898 // linked; the dependency is used only during the compilation phase.
3899 return false
3900 }
Jiyong Parke3867542020-12-03 17:28:25 +09003901
3902 if isLibDepTag && libDepTag.excludeInApex {
3903 return false
3904 }
Colin Cross6e511a92020-07-27 21:26:48 -07003905 }
Colin Crossc1b36442021-05-06 13:42:48 -07003906 if depTag == stubImplDepTag {
3907 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003908 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003909 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003910 if depTag == staticVariantTag {
3911 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3912 // actually mean that the static lib (and its dependencies) are copied into the
3913 // APEX.
3914 return false
3915 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003916 return true
3917}
3918
Jiyong Park45bf82e2020-12-15 22:29:02 +09003919// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003920func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3921 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003922 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3923 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3924 return nil
3925 }
Jooyung Han749dc692020-04-15 11:03:39 +09003926 // We don't check for prebuilt modules
3927 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3928 return nil
3929 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003930
Jooyung Han749dc692020-04-15 11:03:39 +09003931 minSdkVersion := c.MinSdkVersion()
3932 if minSdkVersion == "apex_inherit" {
3933 return nil
3934 }
3935 if minSdkVersion == "" {
3936 // JNI libs within APK-in-APEX fall into here
3937 // Those are okay to set sdk_version instead
3938 // We don't have to check if this is a SDK variant because
3939 // non-SDK variant resets sdk_version, which works too.
3940 minSdkVersion = c.SdkVersion()
3941 }
Dan Albertc8060532020-07-22 22:32:17 -07003942 if minSdkVersion == "" {
3943 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3944 }
3945 // Not using nativeApiLevelFromUser because the context here is not
3946 // necessarily a native context.
3947 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003948 if err != nil {
3949 return err
3950 }
Dan Albertc8060532020-07-22 22:32:17 -07003951
Colin Cross8ca61c12022-10-06 21:00:14 -07003952 // A dependency only needs to support a min_sdk_version at least
3953 // as high as the api level that the architecture was introduced in.
3954 // This allows introducing new architectures in the platform that
3955 // need to be included in apexes that normally require an older
3956 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003957 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003958 if sdkVersion.LessThan(minApiForArch) {
3959 sdkVersion = minApiForArch
3960 }
3961
Dan Albertc8060532020-07-22 22:32:17 -07003962 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003963 return fmt.Errorf("newer SDK(%v)", ver)
3964 }
3965 return nil
3966}
3967
Paul Duffinb5769c12021-05-12 16:16:51 +01003968// Implements android.ApexModule
3969func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3970 // stub libraries and native bridge libraries are always available to platform
3971 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3972}
3973
Jooyung Han91f92032022-02-04 12:36:33 +09003974// Overrides android.ApexModuleBase.UniqueApexVariations
3975func (c *Module) UniqueApexVariations() bool {
3976 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3977 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3978 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09003979 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09003980 return c.UseVndk() && c.IsVndk()
3981}
3982
Inseob Kima1888ce2022-10-04 14:42:02 +09003983func (c *Module) overriddenModules() []string {
3984 if o, ok := c.linker.(overridable); ok {
3985 return o.overriddenModules()
3986 }
3987 return nil
3988}
3989
Rob Seymour925aa092021-08-10 20:42:03 +00003990var _ snapshot.RelativeInstallPath = (*Module)(nil)
3991
Liz Kammer35ca77e2021-12-22 15:31:40 -05003992type moduleType int
3993
3994const (
3995 unknownType moduleType = iota
3996 binary
3997 object
3998 fullLibrary
3999 staticLibrary
4000 sharedLibrary
4001 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00004002 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00004003 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05004004)
4005
4006func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00004007 if c.testBinary() {
4008 // testBinary is also a binary, so this comes before the c.Binary()
4009 // conditional. A testBinary has additional implicit dependencies and
4010 // other test-only semantics.
4011 return testBin
4012 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004013 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004014 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004015 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00004016 } else if c.testLibrary() {
4017 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
4018 // will let them add implicit compile deps on gtest, for example.
4019 //
Liz Kammerefc51d92023-04-21 15:11:25 -04004020 // For now, treat them as regular libraries.
4021 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004022 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05004023 static := false
4024 shared := false
4025 if library, ok := c.linker.(*libraryDecorator); ok {
4026 static = library.MutatedProperties.BuildStatic
4027 shared = library.MutatedProperties.BuildShared
4028 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
4029 static = library.MutatedProperties.BuildStatic
4030 shared = library.MutatedProperties.BuildShared
4031 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004032 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004033 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004034 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004035 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004036 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004037 return staticLibrary
4038 }
4039 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00004040 } else if c.isNDKStubLibrary() {
4041 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05004042 }
4043 return unknownType
4044}
4045
4046// ConvertWithBp2build converts Module to Bazel for bp2build.
4047func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
4048 prebuilt := c.IsPrebuilt()
4049 switch c.typ() {
4050 case binary:
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxb12ff592022-09-01 15:04:04 +00004051 if prebuilt {
4052 prebuiltBinaryBp2Build(ctx, c)
4053 } else {
Jingwen Chen537242c2022-08-24 11:53:27 +00004054 binaryBp2build(ctx, c)
4055 }
4056 case testBin:
4057 if !prebuilt {
4058 testBinaryBp2build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004059 }
4060 case object:
Colin Crossc5075e92022-12-05 16:46:39 -08004061 if prebuilt {
4062 prebuiltObjectBp2Build(ctx, c)
4063 } else {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004064 objectBp2Build(ctx, c)
4065 }
4066 case fullLibrary:
4067 if !prebuilt {
4068 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00004069 } else {
4070 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004071 }
4072 case headerLibrary:
4073 libraryHeadersBp2Build(ctx, c)
4074 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05004075 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00004076 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004077 } else {
4078 sharedOrStaticLibraryBp2Build(ctx, c, true)
4079 }
4080 case sharedLibrary:
4081 if prebuilt {
4082 prebuiltLibrarySharedBp2Build(ctx, c)
4083 } else {
4084 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004085 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00004086 }
4087}
4088
4089var _ android.ApiProvider = (*Module)(nil)
4090
4091func (c *Module) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
Spandan Das4238c652022-09-09 01:38:47 +00004092 if c.IsPrebuilt() {
4093 return
4094 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00004095 switch c.typ() {
Spandan Das4238c652022-09-09 01:38:47 +00004096 case fullLibrary:
4097 apiContributionBp2Build(ctx, c)
4098 case sharedLibrary:
4099 apiContributionBp2Build(ctx, c)
4100 case headerLibrary:
4101 // Aggressively generate api targets for all header modules
4102 // This is necessary since the header module does not know if it is a dep of API surface stub library
4103 apiLibraryHeadersBp2Build(ctx, c)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004104 }
4105}
4106
Colin Crosscfad1192015-11-02 16:43:11 -08004107// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004108type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004109 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004110 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004111 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08004112}
4113
Patrice Arrudac249c712019-03-19 17:00:29 -07004114// cc_defaults provides a set of properties that can be inherited by other cc
4115// modules. A module can use the properties from a cc_defaults using
4116// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4117// merged (when possible) by prepending the default module's values to the
4118// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004119func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004120 return DefaultsFactory()
4121}
4122
Colin Cross36242852017-06-23 15:06:31 -07004123func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004124 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004125
Colin Cross36242852017-06-23 15:06:31 -07004126 module.AddProperties(props...)
4127 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004128 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004129 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004130 &BaseCompilerProperties{},
4131 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004132 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004133 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004134 &StaticProperties{},
4135 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004136 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004137 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004138 &TestLinkerProperties{},
4139 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004140 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004141 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004142 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004143 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004144 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004145 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004146 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004147 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004148 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004149 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004150 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004151 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004152 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07004153 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004154 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004155 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4156 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004157 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004158 )
Colin Crosscfad1192015-11-02 16:43:11 -08004159
Jooyung Hancc372c52019-09-25 15:18:44 +09004160 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004161
4162 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004163}
4164
Jiyong Park2286afd2020-06-16 21:58:53 +09004165func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004166 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004167}
4168
Kiyoung Kim51279d32022-08-24 14:10:46 +09004169func (c *Module) isImportedApiLibrary() bool {
4170 _, ok := c.linker.(*apiLibraryDecorator)
4171 return ok
4172}
4173
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004174func kytheExtractAllFactory() android.Singleton {
4175 return &kytheExtractAllSingleton{}
4176}
4177
4178type kytheExtractAllSingleton struct {
4179}
4180
4181func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4182 var xrefTargets android.Paths
4183 ctx.VisitAllModules(func(module android.Module) {
4184 if ccModule, ok := module.(xref); ok {
4185 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4186 }
4187 })
4188 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4189 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004190 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004191 }
4192}
4193
Jihoon Kangf78a8902022-09-01 22:47:07 +00004194func (c *Module) Partition() string {
4195 if p, ok := c.installer.(interface {
4196 getPartition() string
4197 }); ok {
4198 return p.getPartition()
4199 }
4200 return ""
4201}
4202
Colin Cross06a931b2015-10-28 17:23:31 -07004203var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004204var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004205var BoolPtr = proptools.BoolPtr
4206var String = proptools.String
4207var StringPtr = proptools.StringPtr