blob: 3484000266a10a51e81625a4143fce02eec0a21e [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
Yi Konged79fa32023-06-04 17:15:42 +0900527 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800528 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800529 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800530 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700531 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700532 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900533 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800534 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700535 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700536 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800537 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800538 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800539 getSharedFlags() *SharedFlags
540}
541
542type SharedFlags struct {
543 numSharedFlags int
544 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800545}
546
547type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700548 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800549 ModuleContextIntf
550}
551
552type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700553 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800554 ModuleContextIntf
555}
556
Colin Cross37047f12016-12-13 17:06:13 -0800557type DepsContext interface {
558 android.BottomUpMutatorContext
559 ModuleContextIntf
560}
561
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500562// feature represents additional (optional) steps to building cc-related modules, such as invocation
563// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800564type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800565 flags(ctx ModuleContext, flags Flags) Flags
566 props() []interface{}
567}
568
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500569// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500570// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800571type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700572 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800573 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800574 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700575 compilerProps() []interface{}
576
Colin Cross76fada02016-07-27 10:31:13 -0700577 appendCflags([]string)
578 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700579 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800580}
581
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500582// linker is the interface for a linker decorator object. Individual module types can provide
583// their own implementation for this decorator, and thus specify custom logic regarding build
584// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800585type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700586 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800587 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700588 linkerFlags(ctx ModuleContext, flags Flags) Flags
589 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800590 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700591
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700592 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700593 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900594 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700595
596 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900597 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000598
599 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000600 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
601}
602
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500603// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000604type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500605 sharedLibs []string
606 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
607 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700608 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800609}
610
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500611// installer is the interface for an installer helper object. This helper is responsible for
612// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800613type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700614 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700615 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000616 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800617 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700618 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700619 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900620 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000621 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900622 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800623}
624
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800625type xref interface {
626 XrefCcFiles() android.Paths
627}
628
Inseob Kima1888ce2022-10-04 14:42:02 +0900629type overridable interface {
630 overriddenModules() []string
631}
632
Colin Cross6e511a92020-07-27 21:26:48 -0700633type libraryDependencyKind int
634
635const (
636 headerLibraryDependency = iota
637 sharedLibraryDependency
638 staticLibraryDependency
639)
640
641func (k libraryDependencyKind) String() string {
642 switch k {
643 case headerLibraryDependency:
644 return "headerLibraryDependency"
645 case sharedLibraryDependency:
646 return "sharedLibraryDependency"
647 case staticLibraryDependency:
648 return "staticLibraryDependency"
649 default:
650 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
651 }
652}
653
654type libraryDependencyOrder int
655
656const (
657 earlyLibraryDependency = -1
658 normalLibraryDependency = 0
659 lateLibraryDependency = 1
660)
661
662func (o libraryDependencyOrder) String() string {
663 switch o {
664 case earlyLibraryDependency:
665 return "earlyLibraryDependency"
666 case normalLibraryDependency:
667 return "normalLibraryDependency"
668 case lateLibraryDependency:
669 return "lateLibraryDependency"
670 default:
671 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
672 }
673}
674
675// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
676// tags that have a set of predefined tag objects that are reused for each dependency, a
677// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
678// That means that comparing a libraryDependencyTag for equality will only be equal if all
679// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
680// then check individual metadata fields instead.
681type libraryDependencyTag struct {
682 blueprint.BaseDependencyTag
683
684 // These are exported so that fmt.Printf("%#v") can call their String methods.
685 Kind libraryDependencyKind
686 Order libraryDependencyOrder
687
688 wholeStatic bool
689
690 reexportFlags bool
691 explicitlyVersioned bool
692 dataLib bool
693 ndk bool
694
695 staticUnwinder bool
696
697 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900698
Cindy Zhou18417cb2020-12-10 07:12:38 -0800699 // Whether or not this dependency should skip the apex dependency check
700 skipApexAllowedDependenciesCheck bool
701
Jiyong Parke3867542020-12-03 17:28:25 +0900702 // Whether or not this dependency has to be followed for the apex variants
703 excludeInApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000704
705 // If true, don't automatically export symbols from the static library into a shared library.
706 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700707}
708
709// header returns true if the libraryDependencyTag is tagging a header lib dependency.
710func (d libraryDependencyTag) header() bool {
711 return d.Kind == headerLibraryDependency
712}
713
714// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
715func (d libraryDependencyTag) shared() bool {
716 return d.Kind == sharedLibraryDependency
717}
718
719// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
720func (d libraryDependencyTag) static() bool {
721 return d.Kind == staticLibraryDependency
722}
723
Colin Cross65cb3142021-12-10 23:05:02 +0000724func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
725 if d.shared() {
726 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
727 }
728 return nil
729}
730
731var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
732
Colin Crosse9fe2942020-11-10 18:12:15 -0800733// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
734// binaries or other shared libraries are installed as dependencies.
735func (d libraryDependencyTag) InstallDepNeeded() bool {
736 return d.shared()
737}
738
739var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
740
741// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700742// libraryDependencyTag. Each tag object is created globally and reused for multiple
743// dependencies (although since the object contains no references, assigning a tag to a
744// variable and modifying it will not modify the original). Users can compare the tag
745// returned by ctx.OtherModuleDependencyTag against the global original
746type dependencyTag struct {
747 blueprint.BaseDependencyTag
748 name string
749}
750
Colin Crosse9fe2942020-11-10 18:12:15 -0800751// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
752// libraryDependencyTag, but where the dependency needs to be installed when the parent is
753// installed.
754type installDependencyTag struct {
755 blueprint.BaseDependencyTag
756 android.InstallAlwaysNeededDependencyTag
757 name string
758}
759
Colin Crossc99deeb2016-04-11 15:06:20 -0700760var (
Colin Cross6e511a92020-07-27 21:26:48 -0700761 genSourceDepTag = dependencyTag{name: "gen source"}
762 genHeaderDepTag = dependencyTag{name: "gen header"}
763 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
764 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900765 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700766 reuseObjTag = dependencyTag{name: "reuse objects"}
767 staticVariantTag = dependencyTag{name: "static variant"}
768 vndkExtDepTag = dependencyTag{name: "vndk extends"}
769 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700770 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800771 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700772 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700773 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000774 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500775 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400776 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700777)
778
Roland Levillainf89cd092019-07-29 16:22:59 +0100779func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700780 ccLibDepTag, ok := depTag.(libraryDependencyTag)
781 return ok && ccLibDepTag.shared()
782}
783
784func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
785 ccLibDepTag, ok := depTag.(libraryDependencyTag)
786 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100787}
788
Zach Johnson3df4e632020-11-06 11:56:27 -0800789func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
790 ccLibDepTag, ok := depTag.(libraryDependencyTag)
791 return ok && ccLibDepTag.header()
792}
793
Roland Levillainf89cd092019-07-29 16:22:59 +0100794func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800795 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100796}
797
798func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700799 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100800 return ok && ccDepTag == testPerSrcDepTag
801}
802
Chris Parsonsf874e462022-05-10 13:50:12 -0400803// bazelHandler is the interface for a helper object related to deferring to Bazel for
804// processing a cc module (during Bazel mixed builds). Individual module types should define
805// their own bazel handler if they support being handled by Bazel.
806type BazelHandler interface {
807 // QueueBazelCall invokes request-queueing functions on the BazelContext
808 //so that these requests are handled when Bazel's cquery is invoked.
809 QueueBazelCall(ctx android.BaseModuleContext, label string)
810
811 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
812 // on the current module with given label.
813 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
814}
815
Colin Crossca860ac2016-01-04 14:34:37 -0800816// Module contains the properties and members used by all C/C++ module types, and implements
817// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500818// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
819// interface.
820//
821// To define a C/C++ related module, construct a new Module object and point its delegates to
822// type-specific structs. These delegates will be invoked to register module-specific build
823// statements which may be unique to the module type. For example, module.compiler.compile() should
824// be defined so as to register build statements which are responsible for compiling the module.
825//
826// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
827// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
828// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
829// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800830type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700831 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700832
Liz Kammerea6666f2021-02-17 10:17:28 -0500833 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700834
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700835 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700836 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700837
Colin Crossca860ac2016-01-04 14:34:37 -0800838 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400839 hod android.HostOrDeviceSupported
840 multilib android.Multilib
841 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700842
Paul Duffina0843f62019-12-13 19:50:38 +0000843 // Allowable SdkMemberTypes of this module type.
844 sdkMemberTypes []android.SdkMemberType
845
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500846 // decorator delegates, initialize before calling Init
847 // these may contain module-specific implementations, and effectively allow for custom
848 // type-specific logic. These members may reference different objects or the same object.
849 // Functions of these decorators will be invoked to initialize and register type-specific
850 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500851 compiler compiler
852 linker linker
853 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400854 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500855
856 features []feature
857 stl *stl
858 sanitize *sanitize
859 coverage *coverage
Cory Barkera1da26f2022-06-07 20:12:06 +0000860 fuzzer *fuzzer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500861 sabi *sabi
862 vndkdep *vndkdep
863 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800864 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500865 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800866
Colin Cross31076b32020-10-23 17:22:06 -0700867 library libraryInterface
868
Colin Cross635c3b02016-05-18 15:37:25 -0700869 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800870
Colin Crossb98c8b02016-07-29 13:44:28 -0700871 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700872
873 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800874
875 // Flags used to compile this module
876 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700877
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800878 // Shared flags among build rules of this module
879 sharedFlags SharedFlags
880
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800881 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700882 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900883
884 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800885 // Kythe (source file indexer) paths for this compilation module
886 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700887 // Object .o file output paths for this compilation module
888 objFiles android.Paths
889 // Tidy .tidy file output paths for this compilation module
890 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900891
892 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700893 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700894
895 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700896}
897
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200898func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400899 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
900 if b, ok := c.compiler.(*baseCompiler); ok {
901 hasAidl = b.hasSrcExt(".aidl")
902 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
903 hasProto = b.hasSrcExt(".proto")
904 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
905 hasSysprop = b.hasSrcExt(".sysprop")
906 hasWinMsg = b.hasSrcExt(".mc")
907 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
908 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200909 c.AndroidModuleBase().AddJSONData(d)
910 (*d)["Cc"] = map[string]interface{}{
911 "SdkVersion": c.SdkVersion(),
912 "MinSdkVersion": c.MinSdkVersion(),
913 "VndkVersion": c.VndkVersion(),
914 "ProductSpecific": c.ProductSpecific(),
915 "SocSpecific": c.SocSpecific(),
916 "DeviceSpecific": c.DeviceSpecific(),
917 "InProduct": c.InProduct(),
918 "InVendor": c.InVendor(),
919 "InRamdisk": c.InRamdisk(),
920 "InVendorRamdisk": c.InVendorRamdisk(),
921 "InRecovery": c.InRecovery(),
922 "VendorAvailable": c.VendorAvailable(),
923 "ProductAvailable": c.ProductAvailable(),
924 "RamdiskAvailable": c.RamdiskAvailable(),
925 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
926 "RecoveryAvailable": c.RecoveryAvailable(),
927 "OdmAvailable": c.OdmAvailable(),
928 "InstallInData": c.InstallInData(),
929 "InstallInRamdisk": c.InstallInRamdisk(),
930 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
931 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
932 "InstallInRecovery": c.InstallInRecovery(),
933 "InstallInRoot": c.InstallInRoot(),
934 "IsVndk": c.IsVndk(),
935 "IsVndkExt": c.IsVndkExt(),
936 "IsVndkPrivate": c.IsVndkPrivate(),
937 "IsVndkSp": c.IsVndkSp(),
938 "IsLlndk": c.IsLlndk(),
939 "IsLlndkPublic": c.IsLlndkPublic(),
940 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
941 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
942 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
943 "ApexSdkVersion": c.apexSdkVersion,
944 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400945 "AidlSrcs": hasAidl,
946 "LexSrcs": hasLex,
947 "ProtoSrcs": hasProto,
948 "RenderscriptSrcs": hasRenderscript,
949 "SyspropSrcs": hasSysprop,
950 "WinMsgSrcs": hasWinMsg,
951 "YaccSrsc": hasYacc,
952 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200953 }
954}
955
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500956func (c *Module) SetPreventInstall() {
957 c.Properties.PreventInstall = true
958}
959
960func (c *Module) SetHideFromMake() {
961 c.Properties.HideFromMake = true
962}
963
Ivan Lozanod7586b62021-04-01 09:49:36 -0400964func (c *Module) HiddenFromMake() bool {
965 return c.Properties.HideFromMake
966}
967
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800968func (c *Module) RequiredModuleNames() []string {
969 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
970 if c.ImageVariation().Variation == android.CoreVariation {
971 required = append(required, c.Properties.Target.Platform.Required...)
972 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
973 } else if c.InRecovery() {
974 required = append(required, c.Properties.Target.Recovery.Required...)
975 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
976 }
977 return android.FirstUniqueStrings(required)
978}
979
Ivan Lozano52767be2019-10-18 14:49:46 -0700980func (c *Module) Toc() android.OptionalPath {
981 if c.linker != nil {
982 if library, ok := c.linker.(libraryInterface); ok {
983 return library.toc()
984 }
985 }
986 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
987}
988
989func (c *Module) ApiLevel() string {
990 if c.linker != nil {
991 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700992 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700993 }
994 }
995 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
996}
997
998func (c *Module) Static() bool {
999 if c.linker != nil {
1000 if library, ok := c.linker.(libraryInterface); ok {
1001 return library.static()
1002 }
1003 }
1004 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1005}
1006
1007func (c *Module) Shared() bool {
1008 if c.linker != nil {
1009 if library, ok := c.linker.(libraryInterface); ok {
1010 return library.shared()
1011 }
1012 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001013
Ivan Lozano52767be2019-10-18 14:49:46 -07001014 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1015}
1016
1017func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001018 if c.stl != nil {
1019 return c.stl.Properties.SelectedStl
1020 }
1021 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001022}
1023
Ivan Lozano52767be2019-10-18 14:49:46 -07001024func (c *Module) NdkPrebuiltStl() bool {
1025 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1026 return true
1027 }
1028 return false
1029}
1030
1031func (c *Module) StubDecorator() bool {
1032 if _, ok := c.linker.(*stubDecorator); ok {
1033 return true
1034 }
1035 return false
1036}
1037
1038func (c *Module) SdkVersion() string {
1039 return String(c.Properties.Sdk_version)
1040}
1041
Artur Satayev480e25b2020-04-27 18:53:18 +01001042func (c *Module) MinSdkVersion() string {
1043 return String(c.Properties.Min_sdk_version)
1044}
1045
Jiyong Park5df7bd32021-08-25 16:18:46 +09001046func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001047 if linker, ok := c.linker.(*objectLinker); ok {
1048 return linker.isCrt()
1049 }
1050 return false
1051}
1052
Jiyong Park5df7bd32021-08-25 16:18:46 +09001053func (c *Module) SplitPerApiLevel() bool {
1054 return c.canUseSdk() && c.isCrt()
1055}
1056
Colin Crossc511bc52020-04-07 16:50:32 +00001057func (c *Module) AlwaysSdk() bool {
1058 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1059}
1060
Ivan Lozano183a3212019-10-18 14:18:45 -07001061func (c *Module) CcLibrary() bool {
1062 if c.linker != nil {
1063 if _, ok := c.linker.(*libraryDecorator); ok {
1064 return true
1065 }
Colin Crossd48fe732020-09-23 20:37:24 -07001066 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1067 return true
1068 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001069 }
1070 return false
1071}
1072
1073func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001074 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001075 return true
1076 }
1077 return false
1078}
1079
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001080func (c *Module) RustLibraryInterface() bool {
1081 return false
1082}
1083
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001084func (c *Module) IsFuzzModule() bool {
1085 if _, ok := c.compiler.(*fuzzBinary); ok {
1086 return true
1087 }
1088 return false
1089}
1090
1091func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1092 return c.FuzzModule
1093}
1094
1095func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1096 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1097 return fuzzer.fuzzPackagedModule
1098 }
1099 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1100}
1101
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001102func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001103 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1104 return fuzzer.sharedLibraries
1105 }
1106 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1107}
1108
Ivan Lozano2b262972019-11-21 12:30:50 -08001109func (c *Module) NonCcVariants() bool {
1110 return false
1111}
1112
Ivan Lozano183a3212019-10-18 14:18:45 -07001113func (c *Module) SetStatic() {
1114 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001115 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001116 library.setStatic()
1117 return
1118 }
1119 }
1120 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1121}
1122
1123func (c *Module) SetShared() {
1124 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001125 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001126 library.setShared()
1127 return
1128 }
1129 }
1130 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1131}
1132
1133func (c *Module) BuildStaticVariant() bool {
1134 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001135 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001136 return library.buildStatic()
1137 }
1138 }
1139 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1140}
1141
1142func (c *Module) BuildSharedVariant() bool {
1143 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001144 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001145 return library.buildShared()
1146 }
1147 }
1148 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1149}
1150
1151func (c *Module) Module() android.Module {
1152 return c
1153}
1154
Jiyong Parkc20eee32018-09-05 22:36:17 +09001155func (c *Module) OutputFile() android.OptionalPath {
1156 return c.outputFile
1157}
1158
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001159func (c *Module) CoverageFiles() android.Paths {
1160 if c.linker != nil {
1161 if library, ok := c.linker.(libraryInterface); ok {
1162 return library.objs().coverageFiles
1163 }
1164 }
1165 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1166}
1167
Ivan Lozano183a3212019-10-18 14:18:45 -07001168var _ LinkableInterface = (*Module)(nil)
1169
Jiyong Park719b4462019-01-13 00:39:51 +09001170func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001171 if c.linker != nil {
1172 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001173 }
1174 return nil
1175}
1176
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001177func (c *Module) CoverageOutputFile() android.OptionalPath {
1178 if c.linker != nil {
1179 return c.linker.coverageOutputFilePath()
1180 }
1181 return android.OptionalPath{}
1182}
1183
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001184func (c *Module) RelativeInstallPath() string {
1185 if c.installer != nil {
1186 return c.installer.relativeInstallPath()
1187 }
1188 return ""
1189}
1190
Jooyung Han344d5432019-08-23 11:17:39 +09001191func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001192 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001193}
1194
Colin Cross36242852017-06-23 15:06:31 -07001195func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001196 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001197 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001198 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001199 }
1200 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001201 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001202 }
1203 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001204 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001205 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001206 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001207 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001208 }
Colin Cross16b23492016-01-06 14:41:07 -08001209 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001210 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001211 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001212 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001213 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001214 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001215 if c.fuzzer != nil {
1216 c.AddProperties(c.fuzzer.props()...)
1217 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001218 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001219 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001220 }
Justin Yun8effde42017-06-23 19:24:43 +09001221 if c.vndkdep != nil {
1222 c.AddProperties(c.vndkdep.props()...)
1223 }
Stephen Craneba090d12017-05-09 15:44:35 -07001224 if c.lto != nil {
1225 c.AddProperties(c.lto.props()...)
1226 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001227 if c.afdo != nil {
1228 c.AddProperties(c.afdo.props()...)
1229 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001230 if c.pgo != nil {
1231 c.AddProperties(c.pgo.props()...)
1232 }
Colin Crossca860ac2016-01-04 14:34:37 -08001233 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001234 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001235 }
Colin Crossc472d572015-03-17 15:06:21 -07001236
Colin Cross36242852017-06-23 15:06:31 -07001237 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001238 if c.bazelable {
1239 android.InitBazelModule(c)
1240 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001241 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001242 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001243
Colin Cross36242852017-06-23 15:06:31 -07001244 return c
Colin Crossc472d572015-03-17 15:06:21 -07001245}
1246
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001247// UseVndk() returns true if this module is built against VNDK.
1248// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001249func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001250 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001251}
1252
Colin Crossc511bc52020-04-07 16:50:32 +00001253func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001254 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1255 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001256}
1257
1258func (c *Module) UseSdk() bool {
1259 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001260 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001261 }
1262 return false
1263}
1264
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001265func (c *Module) isCoverageVariant() bool {
1266 return c.coverage.Properties.IsCoverageVariant
1267}
1268
Colin Cross95f1ca02020-10-29 20:47:22 -07001269func (c *Module) IsNdk(config android.Config) bool {
1270 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001271}
1272
Colin Cross127bb8b2020-12-16 16:46:01 -08001273func (c *Module) IsLlndk() bool {
1274 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001275}
1276
Colin Cross127bb8b2020-12-16 16:46:01 -08001277func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001278 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001279}
1280
Colin Cross1f3f1302021-04-26 18:37:44 -07001281func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001282 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001283 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001284}
1285
Colin Cross5271fea2021-04-27 13:06:04 -07001286func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1287 lib := moduleLibraryInterface(m)
1288 return lib != nil && (lib.hasVendorPublicLibrary())
1289}
1290
1291// IsVendorPublicLibrary returns true for vendor public libraries.
1292func (c *Module) IsVendorPublicLibrary() bool {
1293 return c.VendorProperties.IsVendorPublicLibrary
1294}
1295
Ivan Lozanof1868af2022-04-12 13:08:36 -04001296func (c *Module) IsVndkPrebuiltLibrary() bool {
1297 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1298 return true
1299 }
1300 return false
1301}
1302
1303func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1304 return c.Properties.SdkAndPlatformVariantVisibleToMake
1305}
1306
Ivan Lozanod7586b62021-04-01 09:49:36 -04001307func (c *Module) HasLlndkStubs() bool {
1308 lib := moduleLibraryInterface(c)
1309 return lib != nil && lib.hasLLNDKStubs()
1310}
1311
1312func (c *Module) StubsVersion() string {
1313 if lib, ok := c.linker.(versionedInterface); ok {
1314 return lib.stubsVersion()
1315 }
1316 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1317}
1318
Colin Cross127bb8b2020-12-16 16:46:01 -08001319// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1320// and does not set llndk.vendor_available: false.
1321func (c *Module) isImplementationForLLNDKPublic() bool {
1322 library, _ := c.library.(*libraryDecorator)
1323 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001324 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001325}
1326
Justin Yunfd9e8042020-12-23 18:23:14 +09001327// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001328func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001329 // Check if VNDK-core-private or VNDK-SP-private
1330 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001331 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001332 }
1333
1334 // Check if LLNDK-private
1335 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001336 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001337 }
1338
1339 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001340}
1341
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001342// IsVndk() returns true if this module has a vndk variant.
1343// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1344// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001345func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001346 if vndkdep := c.vndkdep; vndkdep != nil {
1347 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001348 }
1349 return false
1350}
1351
Yi Kong4ef54592022-02-14 20:00:10 +08001352func (c *Module) isAfdoCompile() bool {
1353 if afdo := c.afdo; afdo != nil {
Vinh Tran44cb78c2023-03-09 22:07:19 -05001354 return afdo.Properties.FdoProfilePath != nil
Yi Kong4ef54592022-02-14 20:00:10 +08001355 }
1356 return false
1357}
1358
Yi Kong7e53c572018-02-14 18:16:12 +08001359func (c *Module) isPgoCompile() bool {
1360 if pgo := c.pgo; pgo != nil {
1361 return pgo.Properties.PgoCompile
1362 }
1363 return false
1364}
1365
Yi Kongc702ebd2022-08-19 16:02:45 +08001366func (c *Module) isCfi() bool {
1367 if sanitize := c.sanitize; sanitize != nil {
1368 return Bool(sanitize.Properties.Sanitize.Cfi)
1369 }
1370 return false
1371}
1372
Yi Konged79fa32023-06-04 17:15:42 +09001373func (c *Module) isFuzzer() bool {
1374 if sanitize := c.sanitize; sanitize != nil {
1375 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1376 }
1377 return false
1378}
1379
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001380func (c *Module) isNDKStubLibrary() bool {
1381 if _, ok := c.compiler.(*stubDecorator); ok {
1382 return true
1383 }
1384 return false
1385}
1386
Ivan Lozanod7586b62021-04-01 09:49:36 -04001387func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001388 if vndkdep := c.vndkdep; vndkdep != nil {
1389 return vndkdep.isVndkSp()
1390 }
1391 return false
1392}
1393
Ivan Lozanof9e21722020-12-02 09:00:51 -05001394func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001395 if vndkdep := c.vndkdep; vndkdep != nil {
1396 return vndkdep.isVndkExt()
1397 }
1398 return false
1399}
1400
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001401func (c *Module) SubName() string {
1402 return c.Properties.SubName
1403}
1404
Ivan Lozano52767be2019-10-18 14:49:46 -07001405func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001406 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001407}
1408
Logan Chienf3511742017-10-31 18:04:35 +08001409func (c *Module) getVndkExtendsModuleName() string {
1410 if vndkdep := c.vndkdep; vndkdep != nil {
1411 return vndkdep.getVndkExtendsModuleName()
1412 }
1413 return ""
1414}
1415
Jiyong Park25fc6a92018-11-18 18:02:45 +09001416func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001417 if lib := c.library; lib != nil {
1418 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001419 }
1420 return false
1421}
1422
1423func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001424 if lib := c.library; lib != nil {
1425 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001426 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001427 return false
1428}
1429
Alan Stokes73feba32022-11-14 12:21:24 +00001430func (c *Module) IsStubsImplementationRequired() bool {
1431 if lib := c.library; lib != nil {
1432 return lib.isStubsImplementationRequired()
1433 }
1434 return false
1435}
1436
Colin Cross0477b422020-10-13 18:43:54 -07001437// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1438// the implementation. If it is an implementation library it returns its own name.
1439func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1440 name := ctx.OtherModuleName(c)
1441 if versioned, ok := c.linker.(versionedInterface); ok {
1442 name = versioned.implementationModuleName(name)
1443 }
1444 return name
1445}
1446
Martin Stjernholm2856c662020-12-02 15:03:42 +00001447// Similar to ImplementationModuleName, but uses the Make variant of the module
1448// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1449// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1450// under the premise that the prebuilt module overrides its source counterpart
1451// if it is exposed to Make).
1452func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1453 name := c.BaseModuleName()
1454 if versioned, ok := c.linker.(versionedInterface); ok {
1455 name = versioned.implementationModuleName(name)
1456 }
1457 return name
1458}
1459
Jiyong Park7d55b612021-06-11 17:22:09 +09001460func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001461 return Bool(c.Properties.Bootstrap)
1462}
1463
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001464func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001465 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1466 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1467 return false
1468 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001469 return c.linker != nil && c.linker.nativeCoverage()
1470}
1471
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001472func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001473 if p, ok := c.linker.(SnapshotInterface); ok {
1474 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001475 }
1476 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001477}
1478
Bill Peckham945441c2020-08-31 16:07:58 -07001479func (c *Module) ExcludeFromVendorSnapshot() bool {
1480 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1481}
1482
Jose Galmesf7294582020-11-13 12:07:36 -08001483func (c *Module) ExcludeFromRecoverySnapshot() bool {
1484 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1485}
1486
Jiyong Parkf1194352019-02-25 11:05:47 +09001487func isBionic(name string) bool {
1488 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001489 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001490 return true
1491 }
1492 return false
1493}
1494
Martin Stjernholm279de572019-09-10 23:18:20 +01001495func InstallToBootstrap(name string, config android.Config) bool {
Jingwen Chen29743c82023-01-25 17:49:46 +00001496 // NOTE: also update //build/bazel/rules/apex/cc.bzl#_installed_to_bootstrap
1497 // if this list is updated.
Florian Mayer95cd6db2023-03-23 17:48:07 -07001498 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001499 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001500 }
1501 return isBionic(name)
1502}
1503
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001504func (c *Module) XrefCcFiles() android.Paths {
1505 return c.kytheFiles
1506}
1507
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001508func (c *Module) isCfiAssemblySupportEnabled() bool {
1509 return c.sanitize != nil &&
1510 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1511}
1512
Inseob Kim800d1142021-06-14 12:03:51 +09001513func (c *Module) InstallInRoot() bool {
1514 return c.installer != nil && c.installer.installInRoot()
1515}
1516
Colin Crossca860ac2016-01-04 14:34:37 -08001517type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001518 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001519 moduleContextImpl
1520}
1521
Colin Cross37047f12016-12-13 17:06:13 -08001522type depsContext struct {
1523 android.BottomUpMutatorContext
1524 moduleContextImpl
1525}
1526
Colin Crossca860ac2016-01-04 14:34:37 -08001527type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001528 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001529 moduleContextImpl
1530}
1531
1532type moduleContextImpl struct {
1533 mod *Module
1534 ctx BaseModuleContext
1535}
1536
Colin Crossb98c8b02016-07-29 13:44:28 -07001537func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001538 return ctx.mod.toolchain(ctx.ctx)
1539}
1540
1541func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001542 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001543}
1544
1545func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001546 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001547}
1548
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001549func (ctx *moduleContextImpl) testBinary() bool {
1550 return ctx.mod.testBinary()
1551}
1552
Yi Kong56fc1b62022-09-06 16:24:00 +08001553func (ctx *moduleContextImpl) testLibrary() bool {
1554 return ctx.mod.testLibrary()
1555}
1556
Jiyong Park1d1119f2019-07-29 21:27:18 +09001557func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001558 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001559}
1560
Inseob Kim7f283f42020-06-01 21:53:49 +09001561func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001562 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001563}
1564
Inseob Kim1042d292020-06-01 23:23:05 +09001565func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001566 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001567}
1568
Jooyung Hanccce2f22020-03-07 03:45:53 +09001569func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001570 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001571}
1572
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001573func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001574 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001575}
1576
1577func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001578 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001579 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001580 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001581 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001582 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001583 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001584 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001585 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001586 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001587 }
1588 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001589}
1590
Jiyong Parkb35a8192020-08-10 15:59:36 +09001591func (ctx *moduleContextImpl) minSdkVersion() string {
1592 ver := ctx.mod.MinSdkVersion()
1593 if ver == "apex_inherit" && !ctx.isForPlatform() {
1594 ver = ctx.apexSdkVersion().String()
1595 }
1596 if ver == "apex_inherit" || ver == "" {
1597 ver = ctx.sdkVersion()
1598 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001599 // For crt objects, the meaning of min_sdk_version is very different from other types of
1600 // module. For them, min_sdk_version defines the oldest version that the build system will
1601 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1602 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1603 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001604 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1605 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1606 // support such an old version. The version is set to the later version in case when the
1607 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1608 // it's for an APEX.
1609 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1610 if ctx.isForPlatform() {
1611 ver = strconv.Itoa(android.FutureApiLevelInt)
1612 } else { // for apex
1613 ver = ctx.apexSdkVersion().String()
1614 if ver == "" { // in case when min_sdk_version was not set by the APEX
1615 ver = ctx.sdkVersion()
1616 }
1617 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001618 }
1619
Jiyong Parkb35a8192020-08-10 15:59:36 +09001620 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1621 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1622 minSdkVersionInt, err2 := strconv.Atoi(ver)
1623 if err == nil && err2 == nil {
1624 if sdkVersionInt < minSdkVersionInt {
1625 return strconv.Itoa(sdkVersionInt)
1626 }
1627 }
1628 return ver
1629}
1630
1631func (ctx *moduleContextImpl) isSdkVariant() bool {
1632 return ctx.mod.IsSdkVariant()
1633}
1634
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001635func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001636 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001637}
Justin Yun8effde42017-06-23 19:24:43 +09001638
Colin Cross95f1ca02020-10-29 20:47:22 -07001639func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1640 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001641}
1642
Colin Cross127bb8b2020-12-16 16:46:01 -08001643func (ctx *moduleContextImpl) IsLlndk() bool {
1644 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001645}
1646
Colin Cross127bb8b2020-12-16 16:46:01 -08001647func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1648 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001649}
1650
Colin Cross127bb8b2020-12-16 16:46:01 -08001651func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1652 return ctx.mod.isImplementationForLLNDKPublic()
1653}
1654
1655func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1656 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001657}
1658
Logan Chienf3511742017-10-31 18:04:35 +08001659func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001660 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001661}
1662
Yi Kong4ef54592022-02-14 20:00:10 +08001663func (ctx *moduleContextImpl) isAfdoCompile() bool {
1664 return ctx.mod.isAfdoCompile()
1665}
1666
Yi Kong7e53c572018-02-14 18:16:12 +08001667func (ctx *moduleContextImpl) isPgoCompile() bool {
1668 return ctx.mod.isPgoCompile()
1669}
1670
Yi Kongc702ebd2022-08-19 16:02:45 +08001671func (ctx *moduleContextImpl) isCfi() bool {
1672 return ctx.mod.isCfi()
1673}
1674
Yi Konged79fa32023-06-04 17:15:42 +09001675func (ctx *moduleContextImpl) isFuzzer() bool {
1676 return ctx.mod.isFuzzer()
1677}
1678
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001679func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1680 return ctx.mod.isNDKStubLibrary()
1681}
1682
Justin Yun8effde42017-06-23 19:24:43 +09001683func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001684 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001685}
1686
Ivan Lozanof9e21722020-12-02 09:00:51 -05001687func (ctx *moduleContextImpl) IsVndkExt() bool {
1688 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001689}
1690
Colin Cross5271fea2021-04-27 13:06:04 -07001691func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1692 return ctx.mod.IsVendorPublicLibrary()
1693}
1694
Vic Yangefd249e2018-11-12 20:19:56 -08001695func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001696 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001697}
1698
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001699func (ctx *moduleContextImpl) selectedStl() string {
1700 if stl := ctx.mod.stl; stl != nil {
1701 return stl.Properties.SelectedStl
1702 }
1703 return ""
1704}
1705
Ivan Lozanobd721262018-11-27 14:33:03 -08001706func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1707 return ctx.mod.linker.useClangLld(actx)
1708}
1709
Colin Crossce75d2c2016-10-06 16:12:58 -07001710func (ctx *moduleContextImpl) baseModuleName() string {
1711 return ctx.mod.ModuleBase.BaseModuleName()
1712}
1713
Logan Chienf3511742017-10-31 18:04:35 +08001714func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1715 return ctx.mod.getVndkExtendsModuleName()
1716}
1717
Logan Chiene274fc92019-12-03 11:18:32 -08001718func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001719 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001720}
1721
Colin Crosse07f2312020-08-13 11:24:56 -07001722func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001723 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001724}
1725
Dan Albertc8060532020-07-22 22:32:17 -07001726func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001727 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001728}
1729
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001730func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001731 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001732}
1733
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001734func (ctx *moduleContextImpl) nativeCoverage() bool {
1735 return ctx.mod.nativeCoverage()
1736}
1737
Colin Cross56a83212020-09-15 18:30:11 -07001738func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1739 return ctx.mod.DirectlyInAnyApex()
1740}
1741
Colin Cross95b07f22020-12-16 11:06:50 -08001742func (ctx *moduleContextImpl) isPreventInstall() bool {
1743 return ctx.mod.Properties.PreventInstall
1744}
1745
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001746func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1747 shared := &ctx.mod.sharedFlags
1748 if shared.flagsMap == nil {
1749 shared.numSharedFlags = 0
1750 shared.flagsMap = make(map[string]string)
1751 }
1752 return shared
1753}
1754
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001755func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1756 return ctx.mod.isCfiAssemblySupportEnabled()
1757}
1758
Colin Cross635c3b02016-05-18 15:37:25 -07001759func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001760 return &Module{
1761 hod: hod,
1762 multilib: multilib,
1763 }
1764}
1765
Colin Cross635c3b02016-05-18 15:37:25 -07001766func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001767 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001768 module.features = []feature{
1769 &tidyFeature{},
1770 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001771 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001772 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001773 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001774 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001775 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001776 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001777 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001778 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001779 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001780 return module
1781}
1782
Colin Crossce75d2c2016-10-06 16:12:58 -07001783func (c *Module) Prebuilt() *android.Prebuilt {
1784 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1785 return p.prebuilt()
1786 }
1787 return nil
1788}
1789
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001790func (c *Module) IsPrebuilt() bool {
1791 return c.Prebuilt() != nil
1792}
1793
Colin Crossce75d2c2016-10-06 16:12:58 -07001794func (c *Module) Name() string {
1795 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001796 if p, ok := c.linker.(interface {
1797 Name(string) string
1798 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001799 name = p.Name(name)
1800 }
1801 return name
1802}
1803
Alex Light3d673592019-01-18 14:37:31 -08001804func (c *Module) Symlinks() []string {
1805 if p, ok := c.installer.(interface {
1806 symlinkList() []string
1807 }); ok {
1808 return p.symlinkList()
1809 }
1810 return nil
1811}
1812
Roland Levillainf89cd092019-07-29 16:22:59 +01001813func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1814 test, ok := c.linker.(testPerSrc)
1815 return ok && test.isAllTestsVariation()
1816}
1817
Chris Parsons216e10a2020-07-09 17:12:52 -04001818func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001819 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001820 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001821 }); ok {
1822 return p.dataPaths()
1823 }
1824 return nil
1825}
1826
Ivan Lozanof1868af2022-04-12 13:08:36 -04001827func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001828 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1829 // "current", it will append the VNDK version to the name suffix.
1830 var vndkVersion string
1831 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001832 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001833 if c.ProductSpecific() {
1834 // If the module is product specific with 'product_specific: true',
1835 // do not add a name suffix because it is a base module.
1836 return ""
1837 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001838 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001839 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001840 } else {
1841 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001842 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001843 }
1844 if vndkVersion == "current" {
1845 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1846 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001847 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001848 // add version suffix only if the module is using different vndk version than the
1849 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001850 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001851 }
1852 return nameSuffix
1853}
1854
Ivan Lozanof1868af2022-04-12 13:08:36 -04001855func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1856 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001857
1858 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001859 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001860 }
1861
Colin Cross127bb8b2020-12-16 16:46:01 -08001862 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001863 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001864 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1865 // added for product variant only when we have vendor and product variants with core
1866 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001867 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001868 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001869 subName += vendorPublicLibrarySuffix
1870 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001871 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1872 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001873 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001874 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001875 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001876 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001877 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001878 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001879 subName += RecoverySuffix
1880 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1881 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001882 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001883 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001884 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001885 } else if c.IsStubs() && c.IsSdkVariant() {
1886 // Public API surface (NDK)
1887 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1888 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001889 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001890
1891 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001892}
1893
Chris Parsonsf874e462022-05-10 13:50:12 -04001894var _ android.MixedBuildBuildable = (*Module)(nil)
1895
1896func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001897 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001898 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001899 // cc_library is a special case in bp2build; two targets are generated -- one for each
1900 // of the shared and static variants. The shared variant keeps the module name, but the
1901 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001902 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1903 } else {
1904 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001905 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001906 labelNoPrebuilt := bazelModuleLabel
1907 if c.IsPrebuilt() {
1908 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1909 }
1910 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001911}
1912
1913func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1914 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1915}
1916
Jingwen Chen3952a902022-12-12 12:20:58 +00001917// IsMixedBuildSupported returns true if the module should be analyzed by Bazel
Jingwen Chena485d092023-04-20 12:34:08 +00001918// in any of the --bazel-mode(s).
Chris Parsonsf874e462022-05-10 13:50:12 -04001919func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
Yu Liu8860c6c2023-06-07 12:43:26 -07001920 if !allEnabledSanitizersSupportedByBazel(ctx, c) {
Sam Delmericoef69d472023-04-18 17:32:43 -04001921 //TODO(b/278772861) support sanitizers in Bazel rules
Yu Liue4312402023-01-18 09:15:31 -08001922 return false
1923 }
Sam Delmericoef69d472023-04-18 17:32:43 -04001924 return c.bazelHandler != nil
1925}
1926
Yu Liu8860c6c2023-06-07 12:43:26 -07001927func allEnabledSanitizersSupportedByBazel(ctx android.BaseModuleContext, c *Module) bool {
Sam Delmericoef69d472023-04-18 17:32:43 -04001928 if c.sanitize == nil {
1929 return true
1930 }
Yu Liue4312402023-01-18 09:15:31 -08001931 sanitizeProps := &c.sanitize.Properties.SanitizeMutated
Sam Delmericoef69d472023-04-18 17:32:43 -04001932
1933 unsupportedSanitizers := []*bool{
1934 sanitizeProps.Safestack,
Sam Delmericoef69d472023-04-18 17:32:43 -04001935 sanitizeProps.Scudo,
1936 BoolPtr(len(c.sanitize.Properties.Sanitize.Recover) > 0),
Sam Delmericoef69d472023-04-18 17:32:43 -04001937 }
1938 for _, san := range unsupportedSanitizers {
1939 if Bool(san) {
1940 return false
1941 }
1942 }
1943
1944 for _, san := range Sanitizers {
1945 if san == intOverflow {
1946 // TODO(b/261058727): enable mixed builds for all modules with UBSan
1947 // Currently we can only support ubsan when minimum runtime is used.
1948 ubsanEnabled := Bool(sanitizeProps.Integer_overflow) || len(sanitizeProps.Misc_undefined) > 0
Yu Liu8860c6c2023-06-07 12:43:26 -07001949 if !ubsanEnabled || c.MinimalRuntimeNeeded() {
1950 continue
Sam Delmericoef69d472023-04-18 17:32:43 -04001951 }
Yu Liu95497dc2023-05-25 11:15:07 -07001952 } else if san == cfi {
Yu Liu8860c6c2023-06-07 12:43:26 -07001953 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1954 // Only allow cfi if this is an apex variant
1955 if !apexInfo.IsForPlatform() {
1956 continue
1957 }
1958 }
1959 if c.sanitize.isSanitizerEnabled(san) {
Sam Delmericoef69d472023-04-18 17:32:43 -04001960 return false
1961 }
1962 }
1963
1964 return true
Yu Liue4312402023-01-18 09:15:31 -08001965}
1966
1967func GetApexConfigKey(ctx android.BaseModuleContext) *android.ApexConfigKey {
1968 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1969 if !apexInfo.IsForPlatform() {
Yu Liubfb23622023-02-22 10:42:15 -08001970 if !ctx.Config().BazelContext.IsModuleDclaAllowed(ctx.Module().Name()) {
1971 return nil
1972 }
Yu Liue4312402023-01-18 09:15:31 -08001973 apexKey := android.ApexConfigKey{
1974 WithinApex: true,
1975 ApexSdkVersion: findApexSdkVersion(ctx, apexInfo).String(),
1976 }
1977 return &apexKey
1978 }
1979
1980 return nil
Chris Parsonsf874e462022-05-10 13:50:12 -04001981}
1982
1983func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
1984 bazelModuleLabel := c.getBazelModuleLabel(ctx)
Chris Parsonsf874e462022-05-10 13:50:12 -04001985 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
1986
1987 c.Properties.SubName = GetSubnameProperty(ctx, c)
1988 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1989 if !apexInfo.IsForPlatform() {
1990 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05001991 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001992
Chris Parsonsf874e462022-05-10 13:50:12 -04001993 c.makeLinkType = GetMakeLinkType(ctx, c)
1994
1995 mctx := &moduleContext{
1996 ModuleContext: ctx,
1997 moduleContextImpl: moduleContextImpl{
1998 mod: c,
1999 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05002000 }
Chris Parsonsf874e462022-05-10 13:50:12 -04002001 mctx.ctx = mctx
2002
Jingwen Chen3952a902022-12-12 12:20:58 +00002003 // TODO(b/244432500): Get the tradefed config from the bazel target instead
2004 // of generating it with Soong.
Chris Parsonsf874e462022-05-10 13:50:12 -04002005 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002006}
2007
Sam Delmerico75dbca22023-04-20 13:13:25 +00002008func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
2009 ctx := &moduleContext{
2010 ModuleContext: actx,
2011 moduleContextImpl: moduleContextImpl{
2012 mod: c,
2013 },
2014 }
2015 ctx.ctx = ctx
2016 return ctx
2017}
2018
Spandan Das20fce2d2023-04-12 17:21:39 +00002019// TODO (b/277651159): Remove this allowlist
2020var (
2021 skipStubLibraryMultipleApexViolation = map[string]bool{
2022 "libclang_rt.asan": true,
2023 "libclang_rt.hwasan": true,
2024 // runtime apex
2025 "libc": true,
2026 "libc_hwasan": true,
2027 "libdl_android": true,
2028 "libm": true,
2029 "libdl": true,
2030 // art apex
2031 "libandroidio": true,
2032 "libdexfile": true,
2033 "libnativebridge": true,
2034 "libnativehelper": true,
2035 "libnativeloader": true,
2036 "libsigchain": true,
2037 }
2038)
2039
2040// Returns true if a stub library could be installed in multiple apexes
2041func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
2042 // If this is not an apex variant, no check necessary
2043 if !c.InAnyApex() {
2044 return false
2045 }
2046 // If this is not a stub library, no check necessary
2047 if !c.HasStubsVariants() {
2048 return false
2049 }
2050 // Skip the allowlist
2051 // Use BaseModuleName so that this matches prebuilts.
2052 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
2053 return false
2054 }
2055
2056 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
2057 // Stub libraries should not have more than one apex_available
2058 if len(aaWithoutTestApexes) > 1 {
2059 return true
2060 }
2061 // Stub libraries should not use the wildcard
2062 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
2063 return true
2064 }
2065 // Default: no violation
2066 return false
2067}
2068
Chris Parsons8d6e4332021-02-22 16:13:50 -05002069func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05002070 // Handle the case of a test module split by `test_per_src` mutator.
2071 //
2072 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
2073 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
2074 // module and return early, as this module does not produce an output file per se.
2075 if c.IsTestPerSrcAllTestsVariation() {
2076 c.outputFile = android.OptionalPath{}
2077 return
2078 }
2079
Ivan Lozanof1868af2022-04-12 13:08:36 -04002080 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002081 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2082 if !apexInfo.IsForPlatform() {
2083 c.hideApexVariantFromMake = true
2084 }
2085
Chris Parsonseefc9e62021-04-02 17:36:47 -04002086 c.makeLinkType = GetMakeLinkType(actx, c)
2087
Sam Delmerico75dbca22023-04-20 13:13:25 +00002088 ctx := moduleContextFromAndroidModuleContext(actx, c)
Colin Crossca860ac2016-01-04 14:34:37 -08002089
Colin Crossf18e1102017-11-16 14:33:08 -08002090 deps := c.depsToPaths(ctx)
2091 if ctx.Failed() {
2092 return
2093 }
2094
Spandan Das20fce2d2023-04-12 17:21:39 +00002095 if c.stubLibraryMultipleApexViolation(actx) {
2096 actx.PropertyErrorf("apex_available",
2097 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
2098 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002099 if c.Properties.Clang != nil && *c.Properties.Clang == false {
2100 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00002101 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
2102 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002103 }
2104
Colin Crossca860ac2016-01-04 14:34:37 -08002105 flags := Flags{
2106 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002107 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002108 }
Colin Crossca860ac2016-01-04 14:34:37 -08002109 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002110 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002111 }
2112 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002113 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002114 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002115 if c.stl != nil {
2116 flags = c.stl.flags(ctx, flags)
2117 }
Colin Cross16b23492016-01-06 14:41:07 -08002118 if c.sanitize != nil {
2119 flags = c.sanitize.flags(ctx, flags)
2120 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002121 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002122 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002123 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002124 if c.fuzzer != nil {
2125 flags = c.fuzzer.flags(ctx, flags)
2126 }
Stephen Craneba090d12017-05-09 15:44:35 -07002127 if c.lto != nil {
2128 flags = c.lto.flags(ctx, flags)
2129 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002130 if c.afdo != nil {
2131 flags = c.afdo.flags(ctx, flags)
2132 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002133 if c.pgo != nil {
2134 flags = c.pgo.flags(ctx, flags)
2135 }
Colin Crossca860ac2016-01-04 14:34:37 -08002136 for _, feature := range c.features {
2137 flags = feature.flags(ctx, flags)
2138 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002139 if ctx.Failed() {
2140 return
2141 }
2142
Colin Cross4af21ed2019-11-04 09:37:55 -08002143 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2144 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2145 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002146
Colin Cross4af21ed2019-11-04 09:37:55 -08002147 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002148
2149 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002150 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002151 }
2152 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002153 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002154 }
2155
Colin Cross3e5e7782022-06-17 22:17:05 +00002156 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2157
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002158 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002159 // We need access to all the flags seen by a source file.
2160 if c.sabi != nil {
2161 flags = c.sabi.flags(ctx, flags)
2162 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002163
Colin Cross4af21ed2019-11-04 09:37:55 -08002164 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002165
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002166 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002167 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002168 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002169 if ctx.Failed() {
2170 return
2171 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002172 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002173 c.objFiles = objs.objFiles
2174 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002175 }
2176
Colin Crossca860ac2016-01-04 14:34:37 -08002177 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002178 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002179 if ctx.Failed() {
2180 return
2181 }
Colin Cross635c3b02016-05-18 15:37:25 -07002182 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002183
Chris Parsons94a0bba2021-06-04 15:03:47 -04002184 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002185
Jose Galmes6f843bc2020-12-11 13:36:29 -08002186 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2187 // RECOVERY_SNAPSHOT_VERSION is current.
2188 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002189 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002190 i.collectHeadersForSnapshot(ctx)
2191 }
2192 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002193 }
Colin Cross5049f022015-03-18 13:28:46 -07002194
Chris Parsons94a0bba2021-06-04 15:03:47 -04002195 c.maybeInstall(ctx, apexInfo)
2196}
2197
2198func (c *Module) maybeUnhideFromMake() {
2199 // If a lib is directly included in any of the APEXes or is not available to the
2200 // platform (which is often the case when the stub is provided as a prebuilt),
2201 // unhide the stubs variant having the latest version gets visible to make. In
2202 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2203 // force anything in the make world to link against the stubs library. (unless it
2204 // is explicitly referenced via .bootstrap suffix or the module is marked with
2205 // 'bootstrap: true').
2206 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2207 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2208 c.IsStubs() && !c.InVendorRamdisk() {
2209 c.Properties.HideFromMake = false // unhide
2210 // Note: this is still non-installable
2211 }
2212}
2213
Jingwen Chen3952a902022-12-12 12:20:58 +00002214// maybeInstall is called at the end of both GenerateAndroidBuildActions and
2215// ProcessBazelQueryResponse to run the install hooks for installable modules,
2216// like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002217func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002218 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002219 // If the module has been specifically configure to not be installed then
2220 // hide from make as otherwise it will break when running inside make
2221 // as the output path to install will not be specified. Not all uninstallable
2222 // modules can be hidden from make as some are needed for resolving make side
2223 // dependencies.
2224 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002225 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002226 c.SkipInstall()
2227 }
2228
2229 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2230 // to allow using the outputs in a genrule.
2231 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002232 c.installer.install(ctx, c.outputFile.Path())
2233 if ctx.Failed() {
2234 return
Colin Crossca860ac2016-01-04 14:34:37 -08002235 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002236 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002237}
2238
Sam Delmerico5fb794a2023-01-27 16:01:37 -05002239func (c *Module) setAndroidMkVariablesFromCquery(info cquery.CcAndroidMkInfo) {
2240 c.Properties.AndroidMkSharedLibs = info.LocalSharedLibs
2241 c.Properties.AndroidMkStaticLibs = info.LocalStaticLibs
2242 c.Properties.AndroidMkWholeStaticLibs = info.LocalWholeStaticLibs
2243}
2244
Colin Cross0ea8ba82019-06-06 14:33:29 -07002245func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002246 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002247 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002248 }
Colin Crossca860ac2016-01-04 14:34:37 -08002249 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002250}
2251
Colin Crossca860ac2016-01-04 14:34:37 -08002252func (c *Module) begin(ctx BaseModuleContext) {
2253 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002254 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002255 }
Colin Crossca860ac2016-01-04 14:34:37 -08002256 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002257 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002258 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002259 if c.stl != nil {
2260 c.stl.begin(ctx)
2261 }
Colin Cross16b23492016-01-06 14:41:07 -08002262 if c.sanitize != nil {
2263 c.sanitize.begin(ctx)
2264 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002265 if c.coverage != nil {
2266 c.coverage.begin(ctx)
2267 }
Stephen Craneba090d12017-05-09 15:44:35 -07002268 if c.lto != nil {
2269 c.lto.begin(ctx)
2270 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002271 if c.pgo != nil {
2272 c.pgo.begin(ctx)
2273 }
Dan Albert92fe7402020-07-15 13:33:30 -07002274 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002275 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002276 if err != nil {
2277 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002278 c.Properties.Sdk_version = nil
2279 } else {
2280 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002281 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002282 }
Colin Crossca860ac2016-01-04 14:34:37 -08002283}
2284
Colin Cross37047f12016-12-13 17:06:13 -08002285func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002286 deps := Deps{}
2287
2288 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002289 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002290 }
2291 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002292 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002293 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002294 if c.stl != nil {
2295 deps = c.stl.deps(ctx, deps)
2296 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002297 if c.coverage != nil {
2298 deps = c.coverage.deps(ctx, deps)
2299 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002300
Colin Crossb6715442017-10-24 11:13:31 -07002301 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2302 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2303 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2304 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2305 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2306 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002307 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002308
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002309 for _, lib := range deps.ReexportSharedLibHeaders {
2310 if !inList(lib, deps.SharedLibs) {
2311 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2312 }
2313 }
2314
2315 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002316 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2317 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 -07002318 }
2319 }
2320
Colin Cross5950f382016-12-13 12:50:57 -08002321 for _, lib := range deps.ReexportHeaderLibHeaders {
2322 if !inList(lib, deps.HeaderLibs) {
2323 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2324 }
2325 }
2326
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002327 for _, gen := range deps.ReexportGeneratedHeaders {
2328 if !inList(gen, deps.GeneratedHeaders) {
2329 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2330 }
2331 }
2332
Colin Crossc99deeb2016-04-11 15:06:20 -07002333 return deps
2334}
2335
Dan Albert7e9d2952016-08-04 13:02:36 -07002336func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002337 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002338 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002339 moduleContextImpl: moduleContextImpl{
2340 mod: c,
2341 },
2342 }
2343 ctx.ctx = ctx
2344
Vinh Tran44cb78c2023-03-09 22:07:19 -05002345 if !actx.Host() || !ctx.static() || ctx.staticBinary() {
2346 c.afdo.addDep(ctx, actx)
2347 }
2348
Colin Crossca860ac2016-01-04 14:34:37 -08002349 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002350}
2351
Jiyong Park7ed9de32018-10-15 22:25:07 +09002352// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002353func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002354 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2355 version := name[sharp+1:]
2356 libname := name[:sharp]
2357 return libname, version
2358 }
2359 return name, ""
2360}
2361
Dan Albert92fe7402020-07-15 13:33:30 -07002362func GetCrtVariations(ctx android.BottomUpMutatorContext,
2363 m LinkableInterface) []blueprint.Variation {
2364 if ctx.Os() != android.Android {
2365 return nil
2366 }
2367 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002368 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2369 minSdkVersion := m.MinSdkVersion()
2370 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2371 minSdkVersion = m.SdkVersion()
2372 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002373 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2374 if err != nil {
2375 ctx.PropertyErrorf("min_sdk_version", err.Error())
2376 }
Colin Cross363ec762023-01-13 13:45:14 -08002377
2378 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002379 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002380 if apiLevel.LessThan(minApiForArch) {
2381 apiLevel = minApiForArch
2382 }
2383
Dan Albert92fe7402020-07-15 13:33:30 -07002384 return []blueprint.Variation{
2385 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002386 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002387 }
2388 }
2389 return []blueprint.Variation{
2390 {Mutator: "sdk", Variation: ""},
2391 }
2392}
2393
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002394func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2395 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002396
2397 variations = append([]blueprint.Variation(nil), variations...)
2398
Liz Kammer23942242022-04-08 15:41:00 -04002399 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002400 // Version is explicitly specified. i.e. libFoo#30
2401 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002402 if tag, ok := depTag.(libraryDependencyTag); ok {
2403 tag.explicitlyVersioned = true
2404 } else {
2405 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2406 }
Colin Crosse7257d22020-09-24 09:56:18 -07002407 }
Colin Crosse7257d22020-09-24 09:56:18 -07002408
Colin Cross0de8a1e2020-09-18 14:15:30 -07002409 if far {
2410 ctx.AddFarVariationDependencies(variations, depTag, name)
2411 } else {
2412 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002413 }
2414}
2415
Kiyoung Kim487689e2022-07-26 09:48:22 +09002416func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2417 apiImportInfo := multitree.ApiImportInfo{}
2418
2419 if c.Device() {
2420 var apiImportModule []blueprint.Module
2421 if actx.OtherModuleExists("api_imports") {
2422 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2423 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2424 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2425 apiImportInfo = apiInfo
2426 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2427 }
2428 }
2429 }
2430
2431 return apiImportInfo
2432}
2433
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002434func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002435 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002436 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002437 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002438 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2439 // between the modules in the snapshot and the snapshot itself.
2440 var snapshotModule []blueprint.Module
2441 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2442 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2443 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2444 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2445 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002446 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002447 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2448 *snapshotInfo = &snapshot
2449 // republish the snapshot for use in later mutators on this module
2450 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002451 }
2452 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002453 if *snapshotInfo == nil {
2454 *snapshotInfo = &SnapshotInfo{}
2455 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002456 return **snapshotInfo
2457}
2458
Kiyoung Kim487689e2022-07-26 09:48:22 +09002459func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2460 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002461 return snapshot
2462 }
2463
2464 return lib
2465}
2466
2467// RewriteLibs takes a list of names of shared libraries and scans it for three types
2468// of names:
2469//
2470// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002471//
2472// For each of these, it adds the name of the prebuilt module (which will be in
2473// prebuilts/ndk) to the list of nonvariant libs.
2474//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002475// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002476//
2477// For each of these, it adds the name of the ndk_library module to the list of
2478// variant libs.
2479//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002480// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002481//
2482// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002483//
2484// The caller can then know to add the variantLibs dependencies differently from the
2485// nonvariantLibs
2486func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2487 variantLibs = []string{}
2488
2489 nonvariantLibs = []string{}
2490 for _, entry := range list {
2491 // strip #version suffix out
2492 name, _ := StubsLibNameAndVersion(entry)
2493 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002494 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002495 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2496 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2497 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002498 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002499 } else {
2500 // put name#version back
2501 nonvariantLibs = append(nonvariantLibs, entry)
2502 }
2503 }
2504 return nonvariantLibs, variantLibs
2505}
2506
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002507func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2508 nonVariantLibs := []string{}
2509 variantLibs := []string{}
2510
2511 for _, lib := range libs {
2512 replaceLibName := GetReplaceModuleName(lib, replaceList)
2513 if replaceLibName == lib {
2514 // Do not handle any libs which are not in API imports
2515 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2516 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2517 variantLibs = append(variantLibs, replaceLibName)
2518 } else {
2519 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2520 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002521 }
2522
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002523 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002524}
2525
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002526func (c *Module) shouldUseApiSurface() bool {
2527 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2528 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2529 // LLNDK Variant
2530 return true
2531 }
2532
2533 if c.Properties.IsSdkVariant {
2534 // NDK Variant
2535 return true
2536 }
2537
2538 if c.isImportedApiLibrary() {
2539 // API Library should depend on API headers
2540 return true
2541 }
2542 }
2543
2544 return false
2545}
2546
Colin Cross1e676be2016-10-12 14:38:15 -07002547func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002548 if !c.Enabled() {
2549 return
2550 }
2551
Colin Cross37047f12016-12-13 17:06:13 -08002552 ctx := &depsContext{
2553 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002554 moduleContextImpl: moduleContextImpl{
2555 mod: c,
2556 },
2557 }
2558 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002559
Colin Crossc99deeb2016-04-11 15:06:20 -07002560 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002561 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002562
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002563 apiNdkLibs := []string{}
2564 apiLateNdkLibs := []string{}
2565
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002566 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002567 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2568 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2569 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2570 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2571 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002572 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002573
Yo Chiang219968c2020-09-22 18:45:04 +08002574 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2575
Colin Crosse0edaf92021-01-11 17:31:17 -08002576 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002577
Dan Albert914449f2016-06-17 16:45:24 -07002578 variantNdkLibs := []string{}
2579 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002580 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002581 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2582 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2583 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002584
2585 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002586 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002587 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002588 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002589
Colin Cross32ec36c2016-12-15 07:39:51 -08002590 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002591 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002592 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002593 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002594 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002595
Kiyoung Kim51279d32022-08-24 14:10:46 +09002596 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002597 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002598 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2599 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002600 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002601
Spandan Das73bcafc2022-08-18 23:26:00 +00002602 if c.isNDKStubLibrary() {
2603 // ndk_headers do not have any variations
2604 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002605 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002606 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002607 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002608 } else {
2609 actx.AddVariationDependencies(nil, depTag, lib)
2610 }
2611 }
2612
Dan Albertf1d14c72020-07-30 14:32:55 -07002613 if c.isNDKStubLibrary() {
2614 // NDK stubs depend on their implementation because the ABI dumps are
2615 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002616
Spandan Das8b08aea2023-03-14 19:29:34 +00002617 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2618 c.ImageVariation(),
2619 blueprint.Variation{Mutator: "link", Variation: "shared"},
2620 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002621 }
2622
Jiyong Park5d1598f2019-02-25 22:14:17 +09002623 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002624 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002625
Kiyoung Kim487689e2022-07-26 09:48:22 +09002626 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002627
Jiyong Park5d1598f2019-02-25 22:14:17 +09002628 actx.AddVariationDependencies([]blueprint.Variation{
2629 {Mutator: "link", Variation: "static"},
2630 }, depTag, lib)
2631 }
2632
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002633 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002634 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002635 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002636 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002637 }
Jiyong Parke3867542020-12-03 17:28:25 +09002638 if inList(lib, deps.ExcludeLibsForApex) {
2639 depTag.excludeInApex = true
2640 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002641
Kiyoung Kim487689e2022-07-26 09:48:22 +09002642 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002643
Dan Willemsen59339a22018-07-22 21:18:45 -07002644 actx.AddVariationDependencies([]blueprint.Variation{
2645 {Mutator: "link", Variation: "static"},
2646 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002647 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002648
Jooyung Han75568392020-03-20 04:29:24 +09002649 // staticUnwinderDep is treated as staticDep for Q apexes
2650 // so that native libraries/binaries are linked with static unwinder
2651 // because Q libc doesn't have unwinder APIs
2652 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002653 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002654 actx.AddVariationDependencies([]blueprint.Variation{
2655 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002656 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002657 }
2658
Jiyong Park7ed9de32018-10-15 22:25:07 +09002659 // shared lib names without the #version suffix
2660 var sharedLibNames []string
2661
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002662 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002663 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002664 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002665 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002666 }
Jiyong Parke3867542020-12-03 17:28:25 +09002667 if inList(lib, deps.ExcludeLibsForApex) {
2668 depTag.excludeInApex = true
2669 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002670
Jiyong Park73c54ee2019-10-22 20:31:18 +09002671 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002672 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2673 name = apiLibraryName
2674 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002675 sharedLibNames = append(sharedLibNames, name)
2676
Colin Crosse7257d22020-09-24 09:56:18 -07002677 variations := []blueprint.Variation{
2678 {Mutator: "link", Variation: "shared"},
2679 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002680
2681 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2682 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2683 }
2684
2685 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2686 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2687 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002688 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002689
Colin Crossfe9acfe2021-06-14 16:13:03 -07002690 for _, lib := range deps.LateStaticLibs {
2691 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2692 actx.AddVariationDependencies([]blueprint.Variation{
2693 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002694 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002695 }
2696
Colin Cross3e5e7782022-06-17 22:17:05 +00002697 for _, lib := range deps.UnexportedStaticLibs {
2698 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2699 actx.AddVariationDependencies([]blueprint.Variation{
2700 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002701 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002702 }
2703
Jiyong Park7ed9de32018-10-15 22:25:07 +09002704 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002705 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002706 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2707 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2708 // linking against both the stubs lib and the non-stubs lib at the same time.
2709 continue
2710 }
Colin Cross6e511a92020-07-27 21:26:48 -07002711 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002712 variations := []blueprint.Variation{
2713 {Mutator: "link", Variation: "shared"},
2714 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002715 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002716 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002717
Dan Willemsen59339a22018-07-22 21:18:45 -07002718 actx.AddVariationDependencies([]blueprint.Variation{
2719 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002720 }, dataLibDepTag, deps.DataLibs...)
2721
Colin Crossc8caa062021-09-24 16:50:14 -07002722 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2723
Chris Parsons79d66a52020-06-05 17:26:16 -04002724 actx.AddVariationDependencies([]blueprint.Variation{
2725 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002726 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002727
Colin Cross68861832016-07-08 10:41:41 -07002728 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002729
2730 for _, gen := range deps.GeneratedHeaders {
2731 depTag := genHeaderDepTag
2732 if inList(gen, deps.ReexportGeneratedHeaders) {
2733 depTag = genHeaderExportDepTag
2734 }
2735 actx.AddDependency(c, depTag, gen)
2736 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002737
Dan Albert92fe7402020-07-15 13:33:30 -07002738 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002739 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002740 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002741 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002742 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002743 }
Colin Crossc465efd2021-06-11 18:00:04 -07002744 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002745 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002746 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002747 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002748 if deps.DynamicLinker != "" {
2749 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002750 }
Dan Albert914449f2016-06-17 16:45:24 -07002751
2752 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002753
2754 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002755 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002756 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002757 {Mutator: "link", Variation: "shared"},
2758 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002759 actx.AddVariationDependencies([]blueprint.Variation{
2760 {Mutator: "version", Variation: version},
2761 {Mutator: "link", Variation: "shared"},
2762 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002763
2764 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002765 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002766 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002767 {Mutator: "link", Variation: "shared"},
2768 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002769 actx.AddVariationDependencies([]blueprint.Variation{
2770 {Mutator: "version", Variation: version},
2771 {Mutator: "link", Variation: "shared"},
2772 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002773
2774 if vndkdep := c.vndkdep; vndkdep != nil {
2775 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002776 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002777 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002778 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002779 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002780 }
2781 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002782
Vinh Tran367d89d2023-04-28 11:21:25 -04002783 if len(deps.AidlLibs) > 0 {
2784 actx.AddDependency(
2785 c,
2786 aidlLibraryTag,
2787 deps.AidlLibs...,
2788 )
2789 }
2790
Kiyoung Kimee58c932022-10-25 22:59:41 +09002791 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002792}
Colin Cross21b9a242015-03-24 14:15:58 -07002793
Colin Crosse40b4ea2018-10-02 22:25:58 -07002794func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002795 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2796 c.beginMutator(ctx)
2797 }
2798}
2799
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002800// Whether a module can link to another module, taking into
2801// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002802func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002803 tag blueprint.DependencyTag) {
2804
2805 switch t := tag.(type) {
2806 case dependencyTag:
2807 if t != vndkExtDepTag {
2808 return
2809 }
2810 case libraryDependencyTag:
2811 default:
2812 return
2813 }
2814
Ivan Lozanof9e21722020-12-02 09:00:51 -05002815 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002816 // Host code is not restricted
2817 return
2818 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002819
2820 // VNDK is cc.Module supported only for now.
2821 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002822 // Though allowed dependency is limited by the image mutator,
2823 // each vendor and product module needs to check link-type
2824 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002825 if ccTo, ok := to.(*Module); ok {
2826 if ccFrom.vndkdep != nil {
2827 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2828 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002829 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002830 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002831 }
2832 return
2833 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002834 // TODO(b/244244438) : Remove this once all variants are implemented
2835 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2836 return
2837 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002838 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002839 // Platform code can link to anything
2840 return
2841 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002842 if from.InRamdisk() {
2843 // Ramdisk code is not NDK
2844 return
2845 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002846 if from.InVendorRamdisk() {
2847 // Vendor ramdisk code is not NDK
2848 return
2849 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002850 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002851 // Recovery code is not NDK
2852 return
2853 }
Colin Cross31076b32020-10-23 17:22:06 -07002854 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002855 if c.NdkPrebuiltStl() {
2856 // These are allowed, but they don't set sdk_version
2857 return
2858 }
2859 if c.StubDecorator() {
2860 // These aren't real libraries, but are the stub shared libraries that are included in
2861 // the NDK.
2862 return
2863 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002864 if c.isImportedApiLibrary() {
2865 // Imported library from the API surface is a stub library built against interface definition.
2866 return
2867 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002868 }
Logan Chien834b9a62019-01-14 15:39:03 +08002869
Ivan Lozano52767be2019-10-18 14:49:46 -07002870 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002871 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2872 // to link to libc++ (non-NDK and without sdk_version).
2873 return
2874 }
2875
Ivan Lozano52767be2019-10-18 14:49:46 -07002876 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002877 // NDK code linking to platform code is never okay.
2878 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002879 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002880 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002881 }
2882
2883 // At this point we know we have two NDK libraries, but we need to
2884 // check that we're not linking against anything built against a higher
2885 // API level, as it is only valid to link against older or equivalent
2886 // APIs.
2887
Inseob Kim01a28722018-04-11 09:48:45 +09002888 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002889 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002890 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002891 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002892 // Current can't be linked against by anything else.
2893 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002894 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002895 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002896 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002897 if err != nil {
2898 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002899 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002900 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002901 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002902 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002903 if err != nil {
2904 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002905 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002906 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002907 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002908
Inseob Kim01a28722018-04-11 09:48:45 +09002909 if toApi > fromApi {
2910 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002911 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002912 }
2913 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002914 }
Dan Albert202fe492017-12-15 13:56:59 -08002915
2916 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002917 fromStl := from.SelectedStl()
2918 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002919 if fromStl == "" || toStl == "" {
2920 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002921 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002922 // We can be permissive with the system "STL" since it is only the C++
2923 // ABI layer, but in the future we should make sure that everyone is
2924 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002925 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002926 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002927 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2928 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002929 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002930}
2931
Jooyung Han479ca172020-10-19 18:51:07 +09002932func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2933 if c, ok := ctx.Module().(*Module); ok {
2934 ctx.VisitDirectDeps(func(dep android.Module) {
2935 depTag := ctx.OtherModuleDependencyTag(dep)
2936 ccDep, ok := dep.(LinkableInterface)
2937 if ok {
2938 checkLinkType(ctx, c, ccDep, depTag)
2939 }
2940 })
2941 }
2942}
2943
Jiyong Park5fb8c102018-04-09 12:03:06 +09002944// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002945// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2946// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002947// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002948func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2949 check := func(child, parent android.Module) bool {
2950 to, ok := child.(*Module)
2951 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002952 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002953 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002954
Jooyung Hana70f0672019-01-18 15:20:43 +09002955 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2956 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002957 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002958
Jiyong Park0474e1f2021-01-14 14:26:06 +09002959 // These dependencies are not excercised at runtime. Tracking these will give us
2960 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002961 depTag := ctx.OtherModuleDependencyTag(child)
2962 if IsHeaderDepTag(depTag) {
2963 return false
2964 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002965 if depTag == staticVariantTag {
2966 return false
2967 }
2968 if depTag == stubImplDepTag {
2969 return false
2970 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002971
Justin Yun63e9ec72020-10-29 16:49:43 +09002972 // Even if target lib has no vendor variant, keep checking dependency
2973 // graph in case it depends on vendor_available or product_available
2974 // but not double_loadable transtively.
2975 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002976 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002977 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002978
Jiyong Park0474e1f2021-01-14 14:26:06 +09002979 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2980 // one.
2981 if Bool(to.VendorProperties.Double_loadable) {
2982 return true
2983 }
2984
Ivan Lozanod7586b62021-04-01 09:49:36 -04002985 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002986 return false
2987 }
2988
Jooyung Hana70f0672019-01-18 15:20:43 +09002989 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2990 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002991 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002992 return false
2993 }
2994 if module, ok := ctx.Module().(*Module); ok {
2995 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002996 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002997 ctx.WalkDeps(check)
2998 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002999 }
3000 }
3001}
3002
Yu Liue4312402023-01-18 09:15:31 -08003003func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
3004 // For the dependency from platform to apex, use the latest stubs
3005 apexSdkVersion := android.FutureApiLevel
3006 if !apexInfo.IsForPlatform() {
3007 apexSdkVersion = apexInfo.MinSdkVersion
3008 }
3009
3010 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
3011 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
3012 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
3013 // (b/144430859)
3014 apexSdkVersion = android.FutureApiLevel
3015 }
3016
3017 return apexSdkVersion
3018}
3019
Colin Crossc99deeb2016-04-11 15:06:20 -07003020// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07003021func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08003022 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08003023
Colin Cross0de8a1e2020-09-18 14:15:30 -07003024 var directStaticDeps []StaticLibraryInfo
3025 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07003026
Colin Cross0de8a1e2020-09-18 14:15:30 -07003027 reexportExporter := func(exporter FlagExporterInfo) {
3028 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
3029 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
3030 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
3031 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
3032 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09003033 }
3034
Colin Cross56a83212020-09-15 18:30:11 -07003035 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Yu Liue4312402023-01-18 09:15:31 -08003036 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09003037
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003038 skipModuleList := map[string]bool{}
3039
3040 var apiImportInfo multitree.ApiImportInfo
3041 hasApiImportInfo := false
3042
3043 ctx.VisitDirectDeps(func(dep android.Module) {
3044 if dep.Name() == "api_imports" {
3045 apiImportInfo = ctx.OtherModuleProvider(dep, multitree.ApiImportsProvider).(multitree.ApiImportInfo)
3046 hasApiImportInfo = true
3047 }
3048 })
3049
3050 if hasApiImportInfo {
3051 targetStubModuleList := map[string]string{}
3052 targetOrigModuleList := map[string]string{}
3053
3054 // Search for dependency which both original module and API imported library with APEX stub exists
3055 ctx.VisitDirectDeps(func(dep android.Module) {
3056 depName := ctx.OtherModuleName(dep)
3057 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
3058 targetStubModuleList[apiLibrary] = depName
3059 }
3060 })
3061 ctx.VisitDirectDeps(func(dep android.Module) {
3062 depName := ctx.OtherModuleName(dep)
3063 if origLibrary, ok := targetStubModuleList[depName]; ok {
3064 targetOrigModuleList[origLibrary] = depName
3065 }
3066 })
3067
3068 // Decide which library should be used between original and API imported library
3069 ctx.VisitDirectDeps(func(dep android.Module) {
3070 depName := ctx.OtherModuleName(dep)
3071 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00003072 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003073 skipModuleList[depName] = true
3074 } else {
3075 skipModuleList[apiLibrary] = true
3076 }
3077 }
3078 })
3079 }
3080
Colin Crossd11fcda2017-10-23 17:59:01 -07003081 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003082 depName := ctx.OtherModuleName(dep)
3083 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07003084
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003085 if _, ok := skipModuleList[depName]; ok {
3086 // skip this module because original module or API imported module matching with this should be used instead.
3087 return
3088 }
3089
Dan Willemsen47450072021-10-19 20:24:49 -07003090 if depTag == android.DarwinUniversalVariantTag {
3091 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3092 return
3093 }
3094
Vinh Tran367d89d2023-04-28 11:21:25 -04003095 if depTag == aidlLibraryTag {
3096 if ctx.OtherModuleHasProvider(dep, aidl_library.AidlLibraryProvider) {
3097 depPaths.AidlLibraryInfos = append(
3098 depPaths.AidlLibraryInfos,
3099 ctx.OtherModuleProvider(
3100 dep,
3101 aidl_library.AidlLibraryProvider).(aidl_library.AidlLibraryInfo),
3102 )
3103 }
3104 }
3105
Ivan Lozano52767be2019-10-18 14:49:46 -07003106 ccDep, ok := dep.(LinkableInterface)
3107 if !ok {
3108
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003109 // handling for a few module types that aren't cc Module but that are also supported
3110 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003111 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003112 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003113 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3114 genRule.GeneratedSourceFiles()...)
3115 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003116 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003117 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003118 // Support exported headers from a generated_sources dependency
3119 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003120 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003121 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003122 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003123 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003124 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003125 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003126 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003127 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003128 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3129 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003130 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003131 // 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 +09003132 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003133
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003134 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003135 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003136 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003137 }
Colin Crosscef792e2021-06-11 18:01:26 -07003138 case CrtBeginDepTag:
3139 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3140 case CrtEndDepTag:
3141 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003142 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003143 return
3144 }
3145
Colin Crossfe17f6f2019-03-28 19:30:56 -07003146 if depTag == android.ProtoPluginDepTag {
3147 return
3148 }
3149
Colin Crossd11fcda2017-10-23 17:59:01 -07003150 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003151 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3152 return
3153 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003154 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003155 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3156 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003157 return
3158 }
3159
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003160 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003161 // Skip reused objects for stub libraries, they use their own stub object file instead.
3162 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3163 // version mutator, so the stubs variant is created from the shared variant that
3164 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003165 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07003166 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3167 objs := staticAnalogue.ReuseObjects
3168 depPaths.Objs = depPaths.Objs.Append(objs)
3169 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3170 reexportExporter(depExporterInfo)
3171 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003172 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003173 }
3174
Colin Cross6e511a92020-07-27 21:26:48 -07003175 linkFile := ccDep.OutputFile()
3176
3177 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3178 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003179 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003180 return
3181 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003182
Jiyong Parke3867542020-12-03 17:28:25 +09003183 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3184 return
3185 }
3186
Colin Cross0de8a1e2020-09-18 14:15:30 -07003187 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07003188
Colin Cross6e511a92020-07-27 21:26:48 -07003189 var ptr *android.Paths
3190 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003191
Colin Cross6e511a92020-07-27 21:26:48 -07003192 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003193
Colin Cross6e511a92020-07-27 21:26:48 -07003194 switch {
3195 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08003196 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
3197 if !ctx.Config().AllowMissingDependencies() {
3198 ctx.ModuleErrorf("module %q is not a header library", depName)
3199 } else {
3200 ctx.AddMissingDependencies([]string{depName})
3201 }
3202 return
3203 }
Colin Cross6e511a92020-07-27 21:26:48 -07003204 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003205 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
3206 if !ctx.Config().AllowMissingDependencies() {
3207 ctx.ModuleErrorf("module %q is not a shared library", depName)
3208 } else {
3209 ctx.AddMissingDependencies([]string{depName})
3210 }
3211 return
3212 }
Jiyong Parke3867542020-12-03 17:28:25 +09003213
Jiyong Park7d55b612021-06-11 17:22:09 +09003214 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3215 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003216
Jiyong Park1ad8e162020-12-01 23:40:09 +09003217 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3218 // linkFile, depFile, and ptr.
3219 if c.IsStubs() {
3220 break
3221 }
3222
Colin Cross0de8a1e2020-09-18 14:15:30 -07003223 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3224 depFile = sharedLibraryInfo.TableOfContents
3225
Colin Cross6e511a92020-07-27 21:26:48 -07003226 ptr = &depPaths.SharedLibs
3227 switch libDepTag.Order {
3228 case earlyLibraryDependency:
3229 ptr = &depPaths.EarlySharedLibs
3230 depPtr = &depPaths.EarlySharedLibsDeps
3231 case normalLibraryDependency:
3232 ptr = &depPaths.SharedLibs
3233 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003234 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003235 case lateLibraryDependency:
3236 ptr = &depPaths.LateSharedLibs
3237 depPtr = &depPaths.LateSharedLibsDeps
3238 default:
3239 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003240 }
Colin Cross6e511a92020-07-27 21:26:48 -07003241 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003242 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
3243 if !ctx.Config().AllowMissingDependencies() {
3244 ctx.ModuleErrorf("module %q is not a static library", depName)
3245 } else {
3246 ctx.AddMissingDependencies([]string{depName})
3247 }
3248 return
3249 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003250
3251 // Stubs lib doesn't link to the static lib dependencies. Don't set
3252 // linkFile, depFile, and ptr.
3253 if c.IsStubs() {
3254 break
3255 }
3256
Colin Cross0de8a1e2020-09-18 14:15:30 -07003257 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3258 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003259 if libDepTag.wholeStatic {
3260 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003261 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3262 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003263 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003264 // This case normally catches prebuilt static
3265 // libraries, but it can also occur when
3266 // AllowMissingDependencies is on and the
3267 // dependencies has no sources of its own
3268 // but has a whole_static_libs dependency
3269 // on a missing library. We want to depend
3270 // on the .a file so that there is something
3271 // in the dependency tree that contains the
3272 // error rule for the missing transitive
3273 // dependency.
3274 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003275 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003276 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3277 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003278 } else {
3279 switch libDepTag.Order {
3280 case earlyLibraryDependency:
3281 panic(fmt.Errorf("early static libs not suppported"))
3282 case normalLibraryDependency:
3283 // static dependencies will be handled separately so they can be ordered
3284 // using transitive dependencies.
3285 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003286 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003287 case lateLibraryDependency:
3288 ptr = &depPaths.LateStaticLibs
3289 default:
3290 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003291 }
3292 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003293 if libDepTag.unexportedSymbols {
3294 depPaths.LdFlags = append(depPaths.LdFlags,
3295 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3296 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003297 }
3298
Colin Cross6e511a92020-07-27 21:26:48 -07003299 if libDepTag.static() && !libDepTag.wholeStatic {
3300 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3301 ctx.ModuleErrorf("module %q not a static library", depName)
3302 return
3303 }
Logan Chien43d34c32017-12-20 01:17:32 +08003304
Colin Cross6e511a92020-07-27 21:26:48 -07003305 // When combining coverage files for shared libraries and executables, coverage files
3306 // in static libraries act as if they were whole static libraries. The same goes for
3307 // source based Abi dump files.
3308 if c, ok := ccDep.(*Module); ok {
3309 staticLib := c.linker.(libraryInterface)
3310 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3311 staticLib.objs().coverageFiles...)
3312 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3313 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003314 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003315 // Handle non-CC modules here
3316 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003317 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003318 }
3319 }
3320
Colin Cross6e511a92020-07-27 21:26:48 -07003321 if ptr != nil {
3322 if !linkFile.Valid() {
3323 if !ctx.Config().AllowMissingDependencies() {
3324 ctx.ModuleErrorf("module %q missing output file", depName)
3325 } else {
3326 ctx.AddMissingDependencies([]string{depName})
3327 }
3328 return
3329 }
3330 *ptr = append(*ptr, linkFile.Path())
3331 }
3332
3333 if depPtr != nil {
3334 dep := depFile
3335 if !dep.Valid() {
3336 dep = linkFile
3337 }
3338 *depPtr = append(*depPtr, dep.Path())
3339 }
3340
Colin Cross0de8a1e2020-09-18 14:15:30 -07003341 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3342 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3343 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3344 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3345
3346 if libDepTag.reexportFlags {
3347 reexportExporter(depExporterInfo)
3348 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3349 // Re-exported shared library headers must be included as well since they can help us with type information
3350 // about template instantiations (instantiated from their headers).
3351 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3352 // scripts.
3353 c.sabi.Properties.ReexportedIncludes = append(
3354 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3355 }
3356
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003357 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003358 switch {
3359 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003360 c.Properties.AndroidMkHeaderLibs = append(
3361 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003362 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003363 if lib := moduleLibraryInterface(dep); lib != nil {
3364 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003365 // Add the dependency to the APEX(es) providing the library so that
3366 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003367 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003368 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003369 c.Properties.ApexesProvidingSharedLibs = append(
3370 c.Properties.ApexesProvidingSharedLibs, an)
3371 }
3372 }
3373 }
3374
3375 // Note: the order of libs in this list is not important because
3376 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003377 c.Properties.AndroidMkSharedLibs = append(
3378 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003379 // Record BaseLibName for snapshots.
3380 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003381 case libDepTag.static():
3382 if libDepTag.wholeStatic {
3383 c.Properties.AndroidMkWholeStaticLibs = append(
3384 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3385 } else {
3386 c.Properties.AndroidMkStaticLibs = append(
3387 c.Properties.AndroidMkStaticLibs, makeLibName)
3388 }
Justin Yun5e035862021-06-29 20:50:37 +09003389 // Record BaseLibName for snapshots.
3390 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003391 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003392 } else if !c.IsStubs() {
3393 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3394
Colin Cross6e511a92020-07-27 21:26:48 -07003395 switch depTag {
3396 case runtimeDepTag:
3397 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003398 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003399 // Record BaseLibName for snapshots.
3400 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003401 case objDepTag:
3402 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3403 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003404 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003405 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003406 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003407 case dynamicLinkerDepTag:
3408 depPaths.DynamicLinker = linkFile
3409 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003410 }
Colin Crossca860ac2016-01-04 14:34:37 -08003411 })
3412
Jeff Gaston294356f2017-09-27 17:05:30 -07003413 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003414 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3415 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3416 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003417
Colin Crossdd84e052017-05-17 13:44:16 -07003418 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003419 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003420 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3421 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003422 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003423 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3424 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003425 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003426 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003427 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003428
3429 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003430 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003431 }
Colin Crossdd84e052017-05-17 13:44:16 -07003432
Colin Crossca860ac2016-01-04 14:34:37 -08003433 return depPaths
3434}
3435
Spandan Das604f3762023-03-16 22:51:40 +00003436func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003437 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003438 thisModule, ok := ctx.Module().(android.ApexModule)
3439 if !ok {
3440 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3441 }
3442
3443 useVndk := false
3444 bootstrap := false
3445 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3446 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3447 } else {
3448 useVndk = linkable.UseVndk()
3449 bootstrap = linkable.Bootstrap()
3450 }
3451
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003452 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3453
3454 useStubs := false
3455
3456 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3457 if !apexInfo.IsForPlatform() {
3458 // For platform libraries, use current version of LLNDK
3459 // If this is for use_vendor apex we will apply the same rules
3460 // of apex sdk enforcement below to choose right version.
3461 useStubs = true
3462 }
3463 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3464 // If not building for APEX or the containing APEX allows the use of
3465 // platform APIs, use stubs only when it is from an APEX (and not from
3466 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3467 // bootstrap modules, always link to non-stub variant
3468 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3469
3470 isApexImportedApiLibrary := false
3471
3472 if cc, ok := dep.(*Module); ok {
3473 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3474 if apiLibrary.hasApexStubs() {
3475 isApexImportedApiLibrary = true
3476 }
3477 }
3478 }
3479
3480 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3481
3482 if useStubs {
3483 // Another exception: if this module is a test for an APEX, then
3484 // it is linked with the non-stub variant of a module in the APEX
3485 // as if this is part of the APEX.
3486 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3487 for _, apexContents := range testFor.ApexContents {
3488 if apexContents.DirectlyInApex(depName) {
3489 useStubs = false
3490 break
3491 }
3492 }
3493 }
3494 if useStubs {
3495 // Yet another exception: If this module and the dependency are
3496 // available to the same APEXes then skip stubs between their
3497 // platform variants. This complements the test_for case above,
3498 // which avoids the stubs on a direct APEX library dependency, by
3499 // avoiding stubs for indirect test dependencies as well.
3500 //
3501 // TODO(b/183882457): This doesn't work if the two libraries have
3502 // only partially overlapping apex_available. For that test_for
3503 // modules would need to be split into APEX variants and resolved
3504 // separately for each APEX they have access to.
3505 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3506 useStubs = false
3507 }
3508 }
3509 } else {
3510 // If building for APEX, use stubs when the parent is in any APEX that
3511 // the child is not in.
3512 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3513 }
3514
3515 return useStubs
3516}
3517
3518// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3519// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3520// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3521// has different level of updatability. For example, if a library foo in an APEX depends on a
3522// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3523// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3524// same APEX as foo, the non-stub variant of bar is used.
3525func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3526 depTag := ctx.OtherModuleDependencyTag(dep)
3527 libDepTag, ok := depTag.(libraryDependencyTag)
3528 if !ok || !libDepTag.shared() {
3529 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3530 }
3531
Jiyong Park7d55b612021-06-11 17:22:09 +09003532 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3533 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3534 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Jiyong Park7d55b612021-06-11 17:22:09 +09003535
3536 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003537 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003538 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003539 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3540 toUse := stubs[len(stubs)-1]
3541 sharedLibraryInfo = toUse.SharedLibraryInfo
3542 depExporterInfo = toUse.FlagExporterInfo
3543 }
3544 }
3545 return sharedLibraryInfo, depExporterInfo
3546}
3547
Colin Cross0de8a1e2020-09-18 14:15:30 -07003548// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3549// to match the topological order of the dependency tree, including any static analogues of
3550// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3551// of the transitive dependencies.
3552func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3553 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3554 var staticPaths android.Paths
3555 for _, staticDep := range staticDeps {
3556 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3557 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3558 }
3559 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003560 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3561 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003562 }
3563 }
3564 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3565
3566 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3567
3568 // reorder the dependencies based on transitive dependencies
3569 staticPaths = android.FirstUniquePaths(staticPaths)
3570 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3571
3572 if len(orderedStaticPaths) != len(staticPaths) {
3573 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3574 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3575 }
3576
3577 return orderedStaticPaths, transitiveStaticLibs
3578}
3579
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003580// BaseLibName trims known prefixes and suffixes
3581func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003582 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3583 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003584 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003585 return libName
3586}
3587
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003588func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003589 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003590 ccDepModule, _ := ccDep.(*Module)
3591 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003592 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003593
Justin Yuncbca3732021-02-03 19:24:13 +09003594 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003595 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003596 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003597 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003598
Ivan Lozanod1dec542021-05-26 15:33:11 -04003599 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003600 }
3601 }
3602
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003603 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3604 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003605 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3606 // core module instead.
3607 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003608 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003609 // The vendor and product modules in Make will have been renamed to not conflict with the
3610 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003611 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003612 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003613 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003614 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003615 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003616 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003617 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003618 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003619 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003620 } else {
3621 return libName
3622 }
3623}
3624
Colin Crossca860ac2016-01-04 14:34:37 -08003625func (c *Module) InstallInData() bool {
3626 if c.installer == nil {
3627 return false
3628 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003629 return c.installer.inData()
3630}
3631
3632func (c *Module) InstallInSanitizerDir() bool {
3633 if c.installer == nil {
3634 return false
3635 }
3636 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003637 return true
3638 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003639 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003640}
3641
Yifan Hong1b3348d2020-01-21 15:53:22 -08003642func (c *Module) InstallInRamdisk() bool {
3643 return c.InRamdisk()
3644}
3645
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003646func (c *Module) InstallInVendorRamdisk() bool {
3647 return c.InVendorRamdisk()
3648}
3649
Jiyong Parkf9332f12018-02-01 00:54:12 +09003650func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003651 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003652}
3653
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003654func (c *Module) MakeUninstallable() {
3655 if c.installer == nil {
3656 c.ModuleBase.MakeUninstallable()
3657 return
3658 }
3659 c.installer.makeUninstallable(c)
3660}
3661
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003662func (c *Module) HostToolPath() android.OptionalPath {
3663 if c.installer == nil {
3664 return android.OptionalPath{}
3665 }
3666 return c.installer.hostToolPath()
3667}
3668
Nan Zhangd4e641b2017-07-12 12:55:28 -07003669func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3670 return c.outputFile
3671}
3672
Colin Cross41955e82019-05-29 14:40:35 -07003673func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3674 switch tag {
3675 case "":
3676 if c.outputFile.Valid() {
3677 return android.Paths{c.outputFile.Path()}, nil
3678 }
3679 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003680 case "unstripped":
3681 if c.linker != nil {
3682 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3683 }
3684 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003685 default:
3686 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003687 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003688}
3689
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003690func (c *Module) static() bool {
3691 if static, ok := c.linker.(interface {
3692 static() bool
3693 }); ok {
3694 return static.static()
3695 }
3696 return false
3697}
3698
Jiyong Park379de2f2018-12-19 02:47:14 +09003699func (c *Module) staticBinary() bool {
3700 if static, ok := c.linker.(interface {
3701 staticBinary() bool
3702 }); ok {
3703 return static.staticBinary()
3704 }
3705 return false
3706}
3707
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003708func (c *Module) testBinary() bool {
3709 if test, ok := c.linker.(interface {
3710 testBinary() bool
3711 }); ok {
3712 return test.testBinary()
3713 }
3714 return false
3715}
3716
Jingwen Chen537242c2022-08-24 11:53:27 +00003717func (c *Module) testLibrary() bool {
3718 if test, ok := c.linker.(interface {
3719 testLibrary() bool
3720 }); ok {
3721 return test.testLibrary()
3722 }
3723 return false
3724}
3725
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003726func (c *Module) benchmarkBinary() bool {
3727 if b, ok := c.linker.(interface {
3728 benchmarkBinary() bool
3729 }); ok {
3730 return b.benchmarkBinary()
3731 }
3732 return false
3733}
3734
3735func (c *Module) fuzzBinary() bool {
3736 if f, ok := c.linker.(interface {
3737 fuzzBinary() bool
3738 }); ok {
3739 return f.fuzzBinary()
3740 }
3741 return false
3742}
3743
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003744// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3745func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003746 if h, ok := c.linker.(interface {
3747 header() bool
3748 }); ok {
3749 return h.header()
3750 }
3751 return false
3752}
3753
Ivan Lozanod7586b62021-04-01 09:49:36 -04003754func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003755 if b, ok := c.linker.(interface {
3756 binary() bool
3757 }); ok {
3758 return b.binary()
3759 }
3760 return false
3761}
3762
Justin Yun5e035862021-06-29 20:50:37 +09003763func (c *Module) StaticExecutable() bool {
3764 if b, ok := c.linker.(*binaryDecorator); ok {
3765 return b.static()
3766 }
3767 return false
3768}
3769
Ivan Lozanod7586b62021-04-01 09:49:36 -04003770func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003771 if o, ok := c.linker.(interface {
3772 object() bool
3773 }); ok {
3774 return o.object()
3775 }
3776 return false
3777}
3778
Ivan Lozanof9e21722020-12-02 09:00:51 -05003779func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003780 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003781 if c.IsLlndk() {
3782 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003783 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003784 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003785 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003786 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003787 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003788 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003789 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003790 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003791 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003792 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003793 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003794 return "native:product"
3795 }
Jooyung Han38002912019-05-16 04:01:54 +09003796 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003797 } else if c.InRamdisk() {
3798 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003799 } else if c.InVendorRamdisk() {
3800 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003801 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003802 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003803 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003804 return "native:ndk:none:none"
3805 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3806 //family, link := getNdkStlFamilyAndLinkType(c)
3807 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003808 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003809 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003810 } else {
3811 return "native:platform"
3812 }
3813}
3814
Jiyong Park9d452992018-10-03 00:38:19 +09003815// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003816// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003817func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003818 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003819 // Stub libs and prebuilt libs in a versioned SDK are not
3820 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003821 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003822 } else if _, ok := c.linker.(testPerSrc); ok {
3823 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003824 }
3825 return false
3826}
3827
Jiyong Parka90ca002019-10-07 15:47:24 +09003828func (c *Module) AvailableFor(what string) bool {
3829 if linker, ok := c.linker.(interface {
3830 availableFor(string) bool
3831 }); ok {
3832 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3833 } else {
3834 return c.ApexModuleBase.AvailableFor(what)
3835 }
3836}
3837
Jiyong Park62304bb2020-04-13 16:19:48 +09003838func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003839 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003840}
3841
Paul Duffin0cb37b92020-03-04 14:52:46 +00003842func (c *Module) EverInstallable() bool {
3843 return c.installer != nil &&
3844 // Check to see whether the module is actually ever installable.
3845 c.installer.everInstallable()
3846}
3847
Ivan Lozanod7586b62021-04-01 09:49:36 -04003848func (c *Module) PreventInstall() bool {
3849 return c.Properties.PreventInstall
3850}
3851
3852func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003853 if c.library != nil {
3854 if i := c.library.installable(); i != nil {
3855 return i
3856 }
3857 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003858 return c.Properties.Installable
3859}
3860
3861func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003862 ret := c.EverInstallable() &&
3863 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003864 proptools.BoolDefault(c.Installable(), true) &&
3865 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003866
3867 // The platform variant doesn't need further condition. Apex variants however might not
3868 // be installable because it will likely to be included in the APEX and won't appear
3869 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003870 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003871 return ret
3872 }
3873
3874 // Special case for modules that are configured to be installed to /data, which includes
3875 // test modules. For these modules, both APEX and non-APEX variants are considered as
3876 // installable. This is because even the APEX variants won't be included in the APEX, but
3877 // will anyway be installed to /data/*.
3878 // See b/146995717
3879 if c.InstallInData() {
3880 return ret
3881 }
3882
3883 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003884}
3885
Logan Chien41eabe62019-04-10 13:33:58 +08003886func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3887 if c.linker != nil {
3888 if library, ok := c.linker.(*libraryDecorator); ok {
3889 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3890 }
3891 }
3892}
3893
Jiyong Park45bf82e2020-12-15 22:29:02 +09003894var _ android.ApexModule = (*Module)(nil)
3895
3896// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003897func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003898 depTag := ctx.OtherModuleDependencyTag(dep)
3899 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3900
3901 if cc, ok := dep.(*Module); ok {
3902 if cc.HasStubsVariants() {
3903 if isLibDepTag && libDepTag.shared() {
3904 // dynamic dep to a stubs lib crosses APEX boundary
3905 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003906 }
Colin Cross6e511a92020-07-27 21:26:48 -07003907 if IsRuntimeDepTag(depTag) {
3908 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003909 return false
3910 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003911 }
Zhijun Heec285872021-04-24 10:47:08 -07003912 if cc.IsLlndk() {
3913 return false
3914 }
Colin Crossaac32222020-07-29 12:51:56 -07003915 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003916 // shared_lib dependency from a static lib is considered as crossing
3917 // the APEX boundary because the dependency doesn't actually is
3918 // linked; the dependency is used only during the compilation phase.
3919 return false
3920 }
Jiyong Parke3867542020-12-03 17:28:25 +09003921
3922 if isLibDepTag && libDepTag.excludeInApex {
3923 return false
3924 }
Colin Cross6e511a92020-07-27 21:26:48 -07003925 }
Colin Crossc1b36442021-05-06 13:42:48 -07003926 if depTag == stubImplDepTag {
3927 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003928 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003929 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003930 if depTag == staticVariantTag {
3931 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3932 // actually mean that the static lib (and its dependencies) are copied into the
3933 // APEX.
3934 return false
3935 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003936 return true
3937}
3938
Jiyong Park45bf82e2020-12-15 22:29:02 +09003939// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003940func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3941 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003942 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3943 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3944 return nil
3945 }
Jooyung Han749dc692020-04-15 11:03:39 +09003946 // We don't check for prebuilt modules
3947 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3948 return nil
3949 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003950
Jooyung Han749dc692020-04-15 11:03:39 +09003951 minSdkVersion := c.MinSdkVersion()
3952 if minSdkVersion == "apex_inherit" {
3953 return nil
3954 }
3955 if minSdkVersion == "" {
3956 // JNI libs within APK-in-APEX fall into here
3957 // Those are okay to set sdk_version instead
3958 // We don't have to check if this is a SDK variant because
3959 // non-SDK variant resets sdk_version, which works too.
3960 minSdkVersion = c.SdkVersion()
3961 }
Dan Albertc8060532020-07-22 22:32:17 -07003962 if minSdkVersion == "" {
3963 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3964 }
3965 // Not using nativeApiLevelFromUser because the context here is not
3966 // necessarily a native context.
3967 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003968 if err != nil {
3969 return err
3970 }
Dan Albertc8060532020-07-22 22:32:17 -07003971
Colin Cross8ca61c12022-10-06 21:00:14 -07003972 // A dependency only needs to support a min_sdk_version at least
3973 // as high as the api level that the architecture was introduced in.
3974 // This allows introducing new architectures in the platform that
3975 // need to be included in apexes that normally require an older
3976 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003977 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003978 if sdkVersion.LessThan(minApiForArch) {
3979 sdkVersion = minApiForArch
3980 }
3981
Dan Albertc8060532020-07-22 22:32:17 -07003982 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003983 return fmt.Errorf("newer SDK(%v)", ver)
3984 }
3985 return nil
3986}
3987
Paul Duffinb5769c12021-05-12 16:16:51 +01003988// Implements android.ApexModule
3989func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3990 // stub libraries and native bridge libraries are always available to platform
3991 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3992}
3993
Jooyung Han91f92032022-02-04 12:36:33 +09003994// Overrides android.ApexModuleBase.UniqueApexVariations
3995func (c *Module) UniqueApexVariations() bool {
3996 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3997 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3998 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09003999 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09004000 return c.UseVndk() && c.IsVndk()
4001}
4002
Inseob Kima1888ce2022-10-04 14:42:02 +09004003func (c *Module) overriddenModules() []string {
4004 if o, ok := c.linker.(overridable); ok {
4005 return o.overriddenModules()
4006 }
4007 return nil
4008}
4009
Rob Seymour925aa092021-08-10 20:42:03 +00004010var _ snapshot.RelativeInstallPath = (*Module)(nil)
4011
Liz Kammer35ca77e2021-12-22 15:31:40 -05004012type moduleType int
4013
4014const (
4015 unknownType moduleType = iota
4016 binary
4017 object
4018 fullLibrary
4019 staticLibrary
4020 sharedLibrary
4021 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00004022 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00004023 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05004024)
4025
4026func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00004027 if c.testBinary() {
4028 // testBinary is also a binary, so this comes before the c.Binary()
4029 // conditional. A testBinary has additional implicit dependencies and
4030 // other test-only semantics.
4031 return testBin
4032 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004033 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004034 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004035 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00004036 } else if c.testLibrary() {
4037 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
4038 // will let them add implicit compile deps on gtest, for example.
4039 //
Liz Kammerefc51d92023-04-21 15:11:25 -04004040 // For now, treat them as regular libraries.
4041 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004042 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05004043 static := false
4044 shared := false
4045 if library, ok := c.linker.(*libraryDecorator); ok {
4046 static = library.MutatedProperties.BuildStatic
4047 shared = library.MutatedProperties.BuildShared
4048 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
4049 static = library.MutatedProperties.BuildStatic
4050 shared = library.MutatedProperties.BuildShared
4051 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004052 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004053 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004054 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004055 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004056 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004057 return staticLibrary
4058 }
4059 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00004060 } else if c.isNDKStubLibrary() {
4061 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05004062 }
4063 return unknownType
4064}
4065
4066// ConvertWithBp2build converts Module to Bazel for bp2build.
4067func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
4068 prebuilt := c.IsPrebuilt()
4069 switch c.typ() {
4070 case binary:
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxb12ff592022-09-01 15:04:04 +00004071 if prebuilt {
4072 prebuiltBinaryBp2Build(ctx, c)
4073 } else {
Jingwen Chen537242c2022-08-24 11:53:27 +00004074 binaryBp2build(ctx, c)
4075 }
4076 case testBin:
4077 if !prebuilt {
4078 testBinaryBp2build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004079 }
4080 case object:
Colin Crossc5075e92022-12-05 16:46:39 -08004081 if prebuilt {
4082 prebuiltObjectBp2Build(ctx, c)
4083 } else {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004084 objectBp2Build(ctx, c)
4085 }
4086 case fullLibrary:
4087 if !prebuilt {
4088 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00004089 } else {
4090 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004091 }
4092 case headerLibrary:
4093 libraryHeadersBp2Build(ctx, c)
4094 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05004095 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00004096 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004097 } else {
4098 sharedOrStaticLibraryBp2Build(ctx, c, true)
4099 }
4100 case sharedLibrary:
4101 if prebuilt {
4102 prebuiltLibrarySharedBp2Build(ctx, c)
4103 } else {
4104 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004105 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00004106 }
4107}
4108
4109var _ android.ApiProvider = (*Module)(nil)
4110
4111func (c *Module) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
Spandan Das4238c652022-09-09 01:38:47 +00004112 if c.IsPrebuilt() {
4113 return
4114 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00004115 switch c.typ() {
Spandan Das4238c652022-09-09 01:38:47 +00004116 case fullLibrary:
4117 apiContributionBp2Build(ctx, c)
4118 case sharedLibrary:
4119 apiContributionBp2Build(ctx, c)
4120 case headerLibrary:
4121 // Aggressively generate api targets for all header modules
4122 // This is necessary since the header module does not know if it is a dep of API surface stub library
4123 apiLibraryHeadersBp2Build(ctx, c)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004124 }
4125}
4126
Colin Crosscfad1192015-11-02 16:43:11 -08004127// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004128type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004129 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004130 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004131 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08004132}
4133
Patrice Arrudac249c712019-03-19 17:00:29 -07004134// cc_defaults provides a set of properties that can be inherited by other cc
4135// modules. A module can use the properties from a cc_defaults using
4136// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4137// merged (when possible) by prepending the default module's values to the
4138// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004139func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004140 return DefaultsFactory()
4141}
4142
Colin Cross36242852017-06-23 15:06:31 -07004143func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004144 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004145
Colin Cross36242852017-06-23 15:06:31 -07004146 module.AddProperties(props...)
4147 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004148 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004149 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004150 &BaseCompilerProperties{},
4151 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004152 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004153 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004154 &StaticProperties{},
4155 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004156 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004157 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004158 &TestLinkerProperties{},
4159 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004160 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004161 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004162 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004163 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004164 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004165 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004166 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004167 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004168 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004169 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004170 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004171 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004172 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07004173 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004174 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004175 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4176 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004177 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004178 )
Colin Crosscfad1192015-11-02 16:43:11 -08004179
Jooyung Hancc372c52019-09-25 15:18:44 +09004180 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004181
4182 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004183}
4184
Jiyong Park2286afd2020-06-16 21:58:53 +09004185func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004186 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004187}
4188
Kiyoung Kim51279d32022-08-24 14:10:46 +09004189func (c *Module) isImportedApiLibrary() bool {
4190 _, ok := c.linker.(*apiLibraryDecorator)
4191 return ok
4192}
4193
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004194func kytheExtractAllFactory() android.Singleton {
4195 return &kytheExtractAllSingleton{}
4196}
4197
4198type kytheExtractAllSingleton struct {
4199}
4200
4201func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4202 var xrefTargets android.Paths
4203 ctx.VisitAllModules(func(module android.Module) {
4204 if ccModule, ok := module.(xref); ok {
4205 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4206 }
4207 })
4208 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4209 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004210 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004211 }
4212}
4213
Jihoon Kangf78a8902022-09-01 22:47:07 +00004214func (c *Module) Partition() string {
4215 if p, ok := c.installer.(interface {
4216 getPartition() string
4217 }); ok {
4218 return p.getPartition()
4219 }
4220 return ""
4221}
4222
Colin Cross06a931b2015-10-28 17:23:31 -07004223var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004224var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004225var BoolPtr = proptools.BoolPtr
4226var String = proptools.String
4227var StringPtr = proptools.StringPtr