blob: af4b977e62df56e9c6124978f8723e0d8167e6e6 [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
Chris Parsons39a16972023-06-08 14:28:51 +000027 "android/soong/ui/metrics/bp2build_metrics_proto"
Colin Cross97ba0732015-03-23 17:50:24 -070028 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070029 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070030
Vinh Tran367d89d2023-04-28 11:21:25 -040031 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070032 "android/soong/android"
Sam Delmerico5fb794a2023-01-27 16:01:37 -050033 "android/soong/bazel/cquery"
Colin Crossb98c8b02016-07-29 13:44:28 -070034 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070035 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070036 "android/soong/genrule"
Kiyoung Kim487689e2022-07-26 09:48:22 +090037 "android/soong/multitree"
Rob Seymour925aa092021-08-10 20:42:03 +000038 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080039)
40
Colin Cross463a90e2015-06-17 14:20:06 -070041func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000042 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070043
Paul Duffin036e7002019-12-19 19:16:28 +000044 pctx.Import("android/soong/cc/config")
45}
46
47func RegisterCCBuildComponents(ctx android.RegistrationContext) {
48 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
49
50 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000051 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090052 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070053 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010054 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070055 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070056 ctx.BottomUp("begin", BeginMutator).Parallel()
Vinh Tran44cb78c2023-03-09 22:07:19 -050057 ctx.BottomUp("fdo_profile", fdoProfileMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070058 })
Colin Cross16b23492016-01-06 14:41:07 -080059
Paul Duffin036e7002019-12-19 19:16:28 +000060 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040061 for _, san := range Sanitizers {
62 san.registerMutators(ctx)
63 }
Dan Willemsen581341d2017-02-09 16:16:31 -080064
Colin Cross0b908332019-06-19 23:00:20 -070065 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090066 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080067
Cory Barkera1da26f2022-06-07 20:12:06 +000068 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000069
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080070 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070071
Yi Kongeb8efc92021-12-09 18:06:29 +080072 ctx.TopDown("afdo_deps", afdoDepsMutator)
73 ctx.BottomUp("afdo", afdoMutator).Parallel()
74
Stephen Craneba090d12017-05-09 15:44:35 -070075 ctx.TopDown("lto_deps", ltoDepsMutator)
76 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090077
Jooyung Han479ca172020-10-19 18:51:07 +090078 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090079 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070080 })
Colin Crossb98c8b02016-07-29 13:44:28 -070081
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080082 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
83 // sabi mutator needs to be run after apex mutator finishes.
84 ctx.TopDown("sabi_deps", sabiDepsMutator)
85 })
86
LaMont Jones0c10e4d2023-05-16 00:58:37 +000087 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070088}
89
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050090// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
91// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
92// edges to these modules.
93// This object is constructed in DepsMutator, by calling to various module delegates to set
94// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
95// dependencies.
96// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
97// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080098type Deps struct {
99 SharedLibs, LateSharedLibs []string
100 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800101 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800102 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700103
Colin Cross3e5e7782022-06-17 22:17:05 +0000104 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
105 // prevent automatically exporting symbols.
106 UnexportedStaticLibs []string
107
Chris Parsons79d66a52020-06-05 17:26:16 -0400108 // Used for data dependencies adjacent to tests
109 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700110 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400111
Yo Chiang219968c2020-09-22 18:45:04 +0800112 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
113 SystemSharedLibs []string
114
Vinh Tran367d89d2023-04-28 11:21:25 -0400115 // Used by DepMutator to pass aidl_library modules to aidl compiler
116 AidlLibs []string
117
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500118 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800119 StaticUnwinderIfLegacy bool
120
Colin Cross5950f382016-12-13 12:50:57 -0800121 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700122
Colin Cross81413472016-04-11 14:37:39 -0700123 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700124
Dan Willemsenb40aab62016-04-20 14:21:14 -0700125 GeneratedSources []string
126 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900127 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700128
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700129 ReexportGeneratedHeaders []string
130
Colin Crossc465efd2021-06-11 18:00:04 -0700131 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700132
133 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700134 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900135
136 // List of libs that need to be excluded for APEX variant
137 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700138}
139
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500140// PathDeps is a struct containing file paths to dependencies of a module.
141// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
142// It's used to construct flags for various build statements (such as for compiling and linking).
143// It is then passed to module decorator functions responsible for registering build statements
144// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800145type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700146 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900147 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700148 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900149 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700150 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700151 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700152
Colin Cross0de8a1e2020-09-18 14:15:30 -0700153 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossc85750b2022-04-21 12:50:51 -0700154 TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700155
Colin Cross26c34ed2016-09-30 17:10:16 -0700156 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100157 Objs Objects
158 // Paths to .o files in dependencies that provide them. Note that these lists
159 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800160 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700161 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700162
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100163 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
164 // the libs from all whole_static_lib dependencies.
165 WholeStaticLibsFromPrebuilts android.Paths
166
Colin Cross26c34ed2016-09-30 17:10:16 -0700167 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700168 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900169 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700170
Inseob Kimd110f872019-12-06 13:15:38 +0900171 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000172 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900173 IncludeDirs android.Paths
174 SystemIncludeDirs android.Paths
175 ReexportedDirs android.Paths
176 ReexportedSystemDirs android.Paths
177 ReexportedFlags []string
178 ReexportedGeneratedHeaders android.Paths
179 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700180
Colin Cross26c34ed2016-09-30 17:10:16 -0700181 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700182 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700183
Dan Willemsena0790e32018-10-12 00:24:23 -0700184 // Path to the dynamic linker binary
185 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700186
187 // For Darwin builds, the path to the second architecture's output that should
188 // be combined with this architectures's output into a FAT MachO file.
189 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400190
191 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
192 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700193}
194
Colin Cross4af21ed2019-11-04 09:37:55 -0800195// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
196// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
197// command line so they can be overridden by the local module flags).
198type LocalOrGlobalFlags struct {
199 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700200 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800201 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700202 CFlags []string // Flags that apply to C and C++ source files
203 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
204 ConlyFlags []string // Flags that apply to C source files
205 CppFlags []string // Flags that apply to C++ source files
206 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700207 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800208}
209
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500210// Flags contains various types of command line flags (and settings) for use in building build
211// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800212type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500213 // Local flags (which individual modules are responsible for). These may override global flags.
214 Local LocalOrGlobalFlags
215 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800216 Global LocalOrGlobalFlags
217
218 aidlFlags []string // Flags that apply to aidl source files
219 rsFlags []string // Flags that apply to renderscript source files
220 libFlags []string // Flags to add libraries early to the link order
221 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
222 TidyFlags []string // Flags that apply to clang-tidy
223 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700224
Colin Crossc3199482017-03-30 15:03:04 -0700225 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800226 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700227 SystemIncludeFlags []string
228
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800229 Toolchain config.Toolchain
230 Tidy bool // True if ninja .tidy rules should be generated.
231 NeedTidyFiles bool // True if module link should depend on .tidy files
232 GcovCoverage bool // True if coverage files should be generated.
233 SAbiDump bool // True if header abi dumps should be generated.
234 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800235
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500236 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800237 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500238 // The target-device system path to the dynamic linker.
239 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800240
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700241 CFlagsDeps android.Paths // Files depended on by compiler flags
242 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800243
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500244 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700245 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800246
Colin Cross19878da2019-03-28 14:45:07 -0700247 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700248 protoC bool // Whether to use C instead of C++
249 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700250
251 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200252 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700253}
254
Colin Crossca860ac2016-01-04 14:34:37 -0800255// Properties used to compile all C or C++ modules
256type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700257 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800258 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700259
Jiyong Parkb35a8192020-08-10 15:59:36 +0900260 // The API level that this module is built against. The APIs of this API level will be
261 // visible at build time, but use of any APIs newer than min_sdk_version will render the
262 // module unloadable on older devices. In the future it will be possible to weakly-link new
263 // APIs, making the behavior match Java: such modules will load on older devices, but
264 // calling new APIs on devices that do not support them will result in a crash.
265 //
266 // This property has the same behavior as sdk_version does for Java modules. For those
267 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
268 // does for Java code.
269 //
270 // In addition, setting this property causes two variants to be built, one for the platform
271 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800272 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700273
Jiyong Parkb35a8192020-08-10 15:59:36 +0900274 // Minimum OS API level supported by this C or C++ module. This property becomes the value
275 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
276 // this property is also used to ensure that the min_sdk_version of the containing module is
277 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
278 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
279 // min_sdk_version of the containing APEX. When the module
280 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900281 Min_sdk_version *string
282
Colin Crossc511bc52020-04-07 16:50:32 +0000283 // If true, always create an sdk variant and don't create a platform variant.
284 Sdk_variant_only *bool
285
Jiyong Parkde866cb2018-12-07 23:08:36 +0900286 AndroidMkSharedLibs []string `blueprint:"mutated"`
287 AndroidMkStaticLibs []string `blueprint:"mutated"`
288 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
289 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700290 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900291 HideFromMake bool `blueprint:"mutated"`
292 PreventInstall bool `blueprint:"mutated"`
293 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700294
Yo Chiang219968c2020-09-22 18:45:04 +0800295 // Set by DepsMutator.
296 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
297
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200298 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900299 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200300
301 // The VNDK version this module is built against. If empty, the module is not
302 // build against the VNDK.
303 VndkVersion string `blueprint:"mutated"`
304
305 // Suffix for the name of Android.mk entries generated by this module
306 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800307
308 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
309 // file
310 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900311
Yifan Hong39143a92020-10-26 12:43:12 -0700312 // Make this module available when building for ramdisk.
313 // On device without a dedicated recovery partition, the module is only
314 // available after switching root into
315 // /first_stage_ramdisk. To expose the module before switching root, install
316 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800317 Ramdisk_available *bool
318
Yifan Hong39143a92020-10-26 12:43:12 -0700319 // Make this module available when building for vendor ramdisk.
320 // On device without a dedicated recovery partition, the module is only
321 // available after switching root into
322 // /first_stage_ramdisk. To expose the module before switching root, install
323 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700324 Vendor_ramdisk_available *bool
325
Jiyong Parkf9332f12018-02-01 00:54:12 +0900326 // Make this module available when building for recovery
327 Recovery_available *bool
328
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200329 // Used by imageMutator, set by ImageMutatorBegin()
330 CoreVariantNeeded bool `blueprint:"mutated"`
331 RamdiskVariantNeeded bool `blueprint:"mutated"`
332 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
333 RecoveryVariantNeeded bool `blueprint:"mutated"`
334
335 // A list of variations for the "image" mutator of the form
336 //<image name> '.' <version char>, for example, 'vendor.S'
337 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900338
339 // Allows this module to use non-APEX version of libraries. Useful
340 // for building binaries that are started before APEXes are activated.
341 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900342
343 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
344 // see soong/cc/config/vndk.go
345 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900346
347 // Used by vendor snapshot to record dependencies from snapshot modules.
348 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900349 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900350 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000351
Colin Cross1bc94122021-10-28 13:25:54 -0700352 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000353
354 // Set by factories of module types that can only be referenced from variants compiled against
355 // the SDK.
356 AlwaysSdk bool `blueprint:"mutated"`
357
358 // Variant is an SDK variant created by sdkMutator
359 IsSdkVariant bool `blueprint:"mutated"`
360 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
361 // variant to have a ".sdk" suffix.
362 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700363
364 // Normally Soong uses the directory structure to decide which modules
365 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800366 // different snapshots (vendor, recovery, etc.), but this property
367 // allows a partner to exclude a module normally thought of as a
368 // framework module from the vendor snapshot.
369 Exclude_from_vendor_snapshot *bool
370
371 // Normally Soong uses the directory structure to decide which modules
372 // should be included (framework) or excluded (non-framework) from the
373 // different snapshots (vendor, recovery, etc.), but this property
374 // allows a partner to exclude a module normally thought of as a
375 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800376 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900377
378 // List of APEXes that this module has private access to for testing purpose. The module
379 // can depend on libraries that are not exported by the APEXes and use private symbols
380 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000381 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800382
383 Target struct {
384 Platform struct {
385 // List of modules required by the core variant.
386 Required []string `android:"arch_variant"`
387
388 // List of modules not required by the core variant.
389 Exclude_required []string `android:"arch_variant"`
390 } `android:"arch_variant"`
391
392 Recovery struct {
393 // List of modules required by the recovery variant.
394 Required []string `android:"arch_variant"`
395
396 // List of modules not required by the recovery variant.
397 Exclude_required []string `android:"arch_variant"`
398 } `android:"arch_variant"`
399 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700400}
401
402type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900403 // whether this module should be allowed to be directly depended by other
404 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900405 // If set to true, two variants will be built separately, one like
406 // normal, and the other limited to the set of libraries and headers
407 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700408 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900409 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700410 // so it shouldn't have any unversioned runtime dependencies, or
411 // make assumptions about the system that may not be true in the
412 // future.
413 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900414 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900415 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900416 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900417 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900418 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700419 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
420 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900421
Justin Yunebcf0c52021-01-08 18:00:19 +0900422 // This is the same as the "vendor_available" except that the install path
423 // of the vendor variant is /odm or /vendor/odm.
424 // By replacing "vendor_available: true" with "odm_available: true", the
425 // module will install its vendor variant to the /odm partition or /vendor/odm.
426 // As the modules with "odm_available: true" still create the vendor variants,
427 // they can link to the other vendor modules as the vendor_available modules do.
428 // Also, the vendor modules can link to odm_available modules.
429 //
430 // It may not be used for VNDK modules.
431 Odm_available *bool
432
Justin Yun63e9ec72020-10-29 16:49:43 +0900433 // whether this module should be allowed to be directly depended by other
434 // modules with `product_specific: true` or `product_available: true`.
435 // If set to true, an additional product variant will be built separately
436 // that is limited to the set of libraries and headers that are exposed to
437 // /product modules.
438 //
439 // The product variant may be used with a different (newer) /system,
440 // so it shouldn't have any unversioned runtime dependencies, or
441 // make assumptions about the system that may not be true in the
442 // future.
443 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900444 // If set to false, this module becomes inaccessible from /product modules.
445 //
446 // Different from the 'vendor_available' property, the modules with
447 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
448 // library without 'product_available' may not be depended on by any other
449 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900450 //
451 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
452 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
453 Product_available *bool
454
Jiyong Park5fb8c102018-04-09 12:03:06 +0900455 // whether this module is capable of being loaded with other instance
456 // (possibly an older version) of the same module in the same process.
457 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
458 // can be double loaded in a vendor process if the library is also a
459 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
460 // explicitly marked as `double_loadable: true` by the owner, or the dependency
461 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
462 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800463
464 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
465 IsLLNDK bool `blueprint:"mutated"`
466
Colin Cross78212242021-01-06 14:51:30 -0800467 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
468 // set and the module is not listed in VndkMustUseVendorVariantList.
469 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
470
471 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
472 IsVNDKCore bool `blueprint:"mutated"`
473
474 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
475 IsVNDKSP bool `blueprint:"mutated"`
476
477 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
478 // module sets the llndk.private property.
479 IsVNDKPrivate bool `blueprint:"mutated"`
480
481 // IsVNDKProduct is set if a VNDK module sets the product_available property.
482 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700483
484 // IsVendorPublicLibrary is set for the core and product variants of a library that has
485 // vendor_public_library stubs.
486 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800487}
488
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500489// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
490// to understanding details about the type of the current module.
491// For example, one might call these functions to determine whether the current module is a static
492// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800493type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800494 static() bool
495 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700496 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800497 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900498 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900499 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900500 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700501 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900502 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700503 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800504 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900505 minSdkVersion() string
506 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700507 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700508 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800509 IsLlndk() bool
510 IsLlndkPublic() bool
511 isImplementationForLLNDKPublic() bool
512 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900513 isVndk() bool
514 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500515 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700516 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900517 inProduct() bool
518 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800519 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700520 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900521 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700522 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700523 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800524 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800525 isAfdoCompile() bool
Yi Kong7e53c572018-02-14 18:16:12 +0800526 isPgoCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800527 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900528 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800529 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800530 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800531 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700532 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700533 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900534 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800535 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700536 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700537 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800538 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800539 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800540 getSharedFlags() *SharedFlags
541}
542
543type SharedFlags struct {
544 numSharedFlags int
545 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800546}
547
548type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700549 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800550 ModuleContextIntf
551}
552
553type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700554 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800555 ModuleContextIntf
556}
557
Colin Cross37047f12016-12-13 17:06:13 -0800558type DepsContext interface {
559 android.BottomUpMutatorContext
560 ModuleContextIntf
561}
562
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500563// feature represents additional (optional) steps to building cc-related modules, such as invocation
564// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800565type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800566 flags(ctx ModuleContext, flags Flags) Flags
567 props() []interface{}
568}
569
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500570// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500571// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800572type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700573 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800574 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800575 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700576 compilerProps() []interface{}
577
Colin Cross76fada02016-07-27 10:31:13 -0700578 appendCflags([]string)
579 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700580 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800581}
582
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500583// linker is the interface for a linker decorator object. Individual module types can provide
584// their own implementation for this decorator, and thus specify custom logic regarding build
585// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800586type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700587 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800588 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700589 linkerFlags(ctx ModuleContext, flags Flags) Flags
590 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800591 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700592
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700593 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700594 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900595 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700596
597 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900598 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000599
600 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000601 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
602}
603
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500604// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000605type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500606 sharedLibs []string
607 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
608 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700609 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800610}
611
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500612// installer is the interface for an installer helper object. This helper is responsible for
613// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800614type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700615 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700616 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000617 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800618 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700619 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700620 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900621 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000622 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900623 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800624}
625
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800626type xref interface {
627 XrefCcFiles() android.Paths
628}
629
Inseob Kima1888ce2022-10-04 14:42:02 +0900630type overridable interface {
631 overriddenModules() []string
632}
633
Colin Cross6e511a92020-07-27 21:26:48 -0700634type libraryDependencyKind int
635
636const (
637 headerLibraryDependency = iota
638 sharedLibraryDependency
639 staticLibraryDependency
640)
641
642func (k libraryDependencyKind) String() string {
643 switch k {
644 case headerLibraryDependency:
645 return "headerLibraryDependency"
646 case sharedLibraryDependency:
647 return "sharedLibraryDependency"
648 case staticLibraryDependency:
649 return "staticLibraryDependency"
650 default:
651 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
652 }
653}
654
655type libraryDependencyOrder int
656
657const (
658 earlyLibraryDependency = -1
659 normalLibraryDependency = 0
660 lateLibraryDependency = 1
661)
662
663func (o libraryDependencyOrder) String() string {
664 switch o {
665 case earlyLibraryDependency:
666 return "earlyLibraryDependency"
667 case normalLibraryDependency:
668 return "normalLibraryDependency"
669 case lateLibraryDependency:
670 return "lateLibraryDependency"
671 default:
672 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
673 }
674}
675
676// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
677// tags that have a set of predefined tag objects that are reused for each dependency, a
678// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
679// That means that comparing a libraryDependencyTag for equality will only be equal if all
680// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
681// then check individual metadata fields instead.
682type libraryDependencyTag struct {
683 blueprint.BaseDependencyTag
684
685 // These are exported so that fmt.Printf("%#v") can call their String methods.
686 Kind libraryDependencyKind
687 Order libraryDependencyOrder
688
689 wholeStatic bool
690
691 reexportFlags bool
692 explicitlyVersioned bool
693 dataLib bool
694 ndk bool
695
696 staticUnwinder bool
697
698 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900699
Cindy Zhou18417cb2020-12-10 07:12:38 -0800700 // Whether or not this dependency should skip the apex dependency check
701 skipApexAllowedDependenciesCheck bool
702
Jiyong Parke3867542020-12-03 17:28:25 +0900703 // Whether or not this dependency has to be followed for the apex variants
704 excludeInApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000705
706 // If true, don't automatically export symbols from the static library into a shared library.
707 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700708}
709
710// header returns true if the libraryDependencyTag is tagging a header lib dependency.
711func (d libraryDependencyTag) header() bool {
712 return d.Kind == headerLibraryDependency
713}
714
715// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
716func (d libraryDependencyTag) shared() bool {
717 return d.Kind == sharedLibraryDependency
718}
719
720// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
721func (d libraryDependencyTag) static() bool {
722 return d.Kind == staticLibraryDependency
723}
724
Colin Cross65cb3142021-12-10 23:05:02 +0000725func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
726 if d.shared() {
727 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
728 }
729 return nil
730}
731
732var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
733
Colin Crosse9fe2942020-11-10 18:12:15 -0800734// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
735// binaries or other shared libraries are installed as dependencies.
736func (d libraryDependencyTag) InstallDepNeeded() bool {
737 return d.shared()
738}
739
740var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
741
742// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700743// libraryDependencyTag. Each tag object is created globally and reused for multiple
744// dependencies (although since the object contains no references, assigning a tag to a
745// variable and modifying it will not modify the original). Users can compare the tag
746// returned by ctx.OtherModuleDependencyTag against the global original
747type dependencyTag struct {
748 blueprint.BaseDependencyTag
749 name string
750}
751
Colin Crosse9fe2942020-11-10 18:12:15 -0800752// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
753// libraryDependencyTag, but where the dependency needs to be installed when the parent is
754// installed.
755type installDependencyTag struct {
756 blueprint.BaseDependencyTag
757 android.InstallAlwaysNeededDependencyTag
758 name string
759}
760
Colin Crossc99deeb2016-04-11 15:06:20 -0700761var (
Colin Cross6e511a92020-07-27 21:26:48 -0700762 genSourceDepTag = dependencyTag{name: "gen source"}
763 genHeaderDepTag = dependencyTag{name: "gen header"}
764 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
765 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900766 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700767 reuseObjTag = dependencyTag{name: "reuse objects"}
768 staticVariantTag = dependencyTag{name: "static variant"}
769 vndkExtDepTag = dependencyTag{name: "vndk extends"}
770 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700771 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800772 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700773 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700774 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000775 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500776 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400777 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700778)
779
Roland Levillainf89cd092019-07-29 16:22:59 +0100780func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700781 ccLibDepTag, ok := depTag.(libraryDependencyTag)
782 return ok && ccLibDepTag.shared()
783}
784
785func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
786 ccLibDepTag, ok := depTag.(libraryDependencyTag)
787 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100788}
789
Zach Johnson3df4e632020-11-06 11:56:27 -0800790func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
791 ccLibDepTag, ok := depTag.(libraryDependencyTag)
792 return ok && ccLibDepTag.header()
793}
794
Roland Levillainf89cd092019-07-29 16:22:59 +0100795func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800796 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100797}
798
799func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700800 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100801 return ok && ccDepTag == testPerSrcDepTag
802}
803
Chris Parsonsf874e462022-05-10 13:50:12 -0400804// bazelHandler is the interface for a helper object related to deferring to Bazel for
805// processing a cc module (during Bazel mixed builds). Individual module types should define
806// their own bazel handler if they support being handled by Bazel.
807type BazelHandler interface {
808 // QueueBazelCall invokes request-queueing functions on the BazelContext
809 //so that these requests are handled when Bazel's cquery is invoked.
810 QueueBazelCall(ctx android.BaseModuleContext, label string)
811
812 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
813 // on the current module with given label.
814 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
815}
816
Colin Crossca860ac2016-01-04 14:34:37 -0800817// Module contains the properties and members used by all C/C++ module types, and implements
818// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500819// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
820// interface.
821//
822// To define a C/C++ related module, construct a new Module object and point its delegates to
823// type-specific structs. These delegates will be invoked to register module-specific build
824// statements which may be unique to the module type. For example, module.compiler.compile() should
825// be defined so as to register build statements which are responsible for compiling the module.
826//
827// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
828// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
829// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
830// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800831type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700832 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700833
Liz Kammerea6666f2021-02-17 10:17:28 -0500834 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700835
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700836 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700837 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700838
Colin Crossca860ac2016-01-04 14:34:37 -0800839 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400840 hod android.HostOrDeviceSupported
841 multilib android.Multilib
842 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700843
Paul Duffina0843f62019-12-13 19:50:38 +0000844 // Allowable SdkMemberTypes of this module type.
845 sdkMemberTypes []android.SdkMemberType
846
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500847 // decorator delegates, initialize before calling Init
848 // these may contain module-specific implementations, and effectively allow for custom
849 // type-specific logic. These members may reference different objects or the same object.
850 // Functions of these decorators will be invoked to initialize and register type-specific
851 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500852 compiler compiler
853 linker linker
854 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400855 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500856
857 features []feature
858 stl *stl
859 sanitize *sanitize
860 coverage *coverage
Cory Barkera1da26f2022-06-07 20:12:06 +0000861 fuzzer *fuzzer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500862 sabi *sabi
863 vndkdep *vndkdep
864 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800865 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500866 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800867
Colin Cross31076b32020-10-23 17:22:06 -0700868 library libraryInterface
869
Colin Cross635c3b02016-05-18 15:37:25 -0700870 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800871
Colin Crossb98c8b02016-07-29 13:44:28 -0700872 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700873
874 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800875
876 // Flags used to compile this module
877 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700878
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800879 // Shared flags among build rules of this module
880 sharedFlags SharedFlags
881
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800882 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700883 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900884
885 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800886 // Kythe (source file indexer) paths for this compilation module
887 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700888 // Object .o file output paths for this compilation module
889 objFiles android.Paths
890 // Tidy .tidy file output paths for this compilation module
891 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900892
893 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700894 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700895
896 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700897}
898
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200899func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400900 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
901 if b, ok := c.compiler.(*baseCompiler); ok {
902 hasAidl = b.hasSrcExt(".aidl")
903 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
904 hasProto = b.hasSrcExt(".proto")
905 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
906 hasSysprop = b.hasSrcExt(".sysprop")
907 hasWinMsg = b.hasSrcExt(".mc")
908 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
909 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200910 c.AndroidModuleBase().AddJSONData(d)
911 (*d)["Cc"] = map[string]interface{}{
912 "SdkVersion": c.SdkVersion(),
913 "MinSdkVersion": c.MinSdkVersion(),
914 "VndkVersion": c.VndkVersion(),
915 "ProductSpecific": c.ProductSpecific(),
916 "SocSpecific": c.SocSpecific(),
917 "DeviceSpecific": c.DeviceSpecific(),
918 "InProduct": c.InProduct(),
919 "InVendor": c.InVendor(),
920 "InRamdisk": c.InRamdisk(),
921 "InVendorRamdisk": c.InVendorRamdisk(),
922 "InRecovery": c.InRecovery(),
923 "VendorAvailable": c.VendorAvailable(),
924 "ProductAvailable": c.ProductAvailable(),
925 "RamdiskAvailable": c.RamdiskAvailable(),
926 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
927 "RecoveryAvailable": c.RecoveryAvailable(),
928 "OdmAvailable": c.OdmAvailable(),
929 "InstallInData": c.InstallInData(),
930 "InstallInRamdisk": c.InstallInRamdisk(),
931 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
932 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
933 "InstallInRecovery": c.InstallInRecovery(),
934 "InstallInRoot": c.InstallInRoot(),
935 "IsVndk": c.IsVndk(),
936 "IsVndkExt": c.IsVndkExt(),
937 "IsVndkPrivate": c.IsVndkPrivate(),
938 "IsVndkSp": c.IsVndkSp(),
939 "IsLlndk": c.IsLlndk(),
940 "IsLlndkPublic": c.IsLlndkPublic(),
941 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
942 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
943 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
944 "ApexSdkVersion": c.apexSdkVersion,
945 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400946 "AidlSrcs": hasAidl,
947 "LexSrcs": hasLex,
948 "ProtoSrcs": hasProto,
949 "RenderscriptSrcs": hasRenderscript,
950 "SyspropSrcs": hasSysprop,
951 "WinMsgSrcs": hasWinMsg,
952 "YaccSrsc": hasYacc,
953 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200954 }
955}
956
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500957func (c *Module) SetPreventInstall() {
958 c.Properties.PreventInstall = true
959}
960
961func (c *Module) SetHideFromMake() {
962 c.Properties.HideFromMake = true
963}
964
Ivan Lozanod7586b62021-04-01 09:49:36 -0400965func (c *Module) HiddenFromMake() bool {
966 return c.Properties.HideFromMake
967}
968
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800969func (c *Module) RequiredModuleNames() []string {
970 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
971 if c.ImageVariation().Variation == android.CoreVariation {
972 required = append(required, c.Properties.Target.Platform.Required...)
973 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
974 } else if c.InRecovery() {
975 required = append(required, c.Properties.Target.Recovery.Required...)
976 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
977 }
978 return android.FirstUniqueStrings(required)
979}
980
Ivan Lozano52767be2019-10-18 14:49:46 -0700981func (c *Module) Toc() android.OptionalPath {
982 if c.linker != nil {
983 if library, ok := c.linker.(libraryInterface); ok {
984 return library.toc()
985 }
986 }
987 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
988}
989
990func (c *Module) ApiLevel() string {
991 if c.linker != nil {
992 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700993 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700994 }
995 }
996 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
997}
998
999func (c *Module) Static() bool {
1000 if c.linker != nil {
1001 if library, ok := c.linker.(libraryInterface); ok {
1002 return library.static()
1003 }
1004 }
1005 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1006}
1007
1008func (c *Module) Shared() bool {
1009 if c.linker != nil {
1010 if library, ok := c.linker.(libraryInterface); ok {
1011 return library.shared()
1012 }
1013 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001014
Ivan Lozano52767be2019-10-18 14:49:46 -07001015 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1016}
1017
1018func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001019 if c.stl != nil {
1020 return c.stl.Properties.SelectedStl
1021 }
1022 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001023}
1024
Ivan Lozano52767be2019-10-18 14:49:46 -07001025func (c *Module) NdkPrebuiltStl() bool {
1026 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1027 return true
1028 }
1029 return false
1030}
1031
1032func (c *Module) StubDecorator() bool {
1033 if _, ok := c.linker.(*stubDecorator); ok {
1034 return true
1035 }
1036 return false
1037}
1038
1039func (c *Module) SdkVersion() string {
1040 return String(c.Properties.Sdk_version)
1041}
1042
Artur Satayev480e25b2020-04-27 18:53:18 +01001043func (c *Module) MinSdkVersion() string {
1044 return String(c.Properties.Min_sdk_version)
1045}
1046
Jiyong Park5df7bd32021-08-25 16:18:46 +09001047func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001048 if linker, ok := c.linker.(*objectLinker); ok {
1049 return linker.isCrt()
1050 }
1051 return false
1052}
1053
Jiyong Park5df7bd32021-08-25 16:18:46 +09001054func (c *Module) SplitPerApiLevel() bool {
1055 return c.canUseSdk() && c.isCrt()
1056}
1057
Colin Crossc511bc52020-04-07 16:50:32 +00001058func (c *Module) AlwaysSdk() bool {
1059 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1060}
1061
Ivan Lozano183a3212019-10-18 14:18:45 -07001062func (c *Module) CcLibrary() bool {
1063 if c.linker != nil {
1064 if _, ok := c.linker.(*libraryDecorator); ok {
1065 return true
1066 }
Colin Crossd48fe732020-09-23 20:37:24 -07001067 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1068 return true
1069 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001070 }
1071 return false
1072}
1073
1074func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001075 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001076 return true
1077 }
1078 return false
1079}
1080
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001081func (c *Module) RustLibraryInterface() bool {
1082 return false
1083}
1084
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001085func (c *Module) IsFuzzModule() bool {
1086 if _, ok := c.compiler.(*fuzzBinary); ok {
1087 return true
1088 }
1089 return false
1090}
1091
1092func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1093 return c.FuzzModule
1094}
1095
1096func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1097 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1098 return fuzzer.fuzzPackagedModule
1099 }
1100 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1101}
1102
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001103func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001104 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1105 return fuzzer.sharedLibraries
1106 }
1107 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1108}
1109
Ivan Lozano2b262972019-11-21 12:30:50 -08001110func (c *Module) NonCcVariants() bool {
1111 return false
1112}
1113
Ivan Lozano183a3212019-10-18 14:18:45 -07001114func (c *Module) SetStatic() {
1115 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001116 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001117 library.setStatic()
1118 return
1119 }
1120 }
1121 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1122}
1123
1124func (c *Module) SetShared() {
1125 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001126 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001127 library.setShared()
1128 return
1129 }
1130 }
1131 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1132}
1133
1134func (c *Module) BuildStaticVariant() bool {
1135 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001136 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001137 return library.buildStatic()
1138 }
1139 }
1140 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1141}
1142
1143func (c *Module) BuildSharedVariant() bool {
1144 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001145 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001146 return library.buildShared()
1147 }
1148 }
1149 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1150}
1151
1152func (c *Module) Module() android.Module {
1153 return c
1154}
1155
Jiyong Parkc20eee32018-09-05 22:36:17 +09001156func (c *Module) OutputFile() android.OptionalPath {
1157 return c.outputFile
1158}
1159
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001160func (c *Module) CoverageFiles() android.Paths {
1161 if c.linker != nil {
1162 if library, ok := c.linker.(libraryInterface); ok {
1163 return library.objs().coverageFiles
1164 }
1165 }
1166 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1167}
1168
Ivan Lozano183a3212019-10-18 14:18:45 -07001169var _ LinkableInterface = (*Module)(nil)
1170
Jiyong Park719b4462019-01-13 00:39:51 +09001171func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001172 if c.linker != nil {
1173 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001174 }
1175 return nil
1176}
1177
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001178func (c *Module) CoverageOutputFile() android.OptionalPath {
1179 if c.linker != nil {
1180 return c.linker.coverageOutputFilePath()
1181 }
1182 return android.OptionalPath{}
1183}
1184
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001185func (c *Module) RelativeInstallPath() string {
1186 if c.installer != nil {
1187 return c.installer.relativeInstallPath()
1188 }
1189 return ""
1190}
1191
Jooyung Han344d5432019-08-23 11:17:39 +09001192func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001193 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001194}
1195
Colin Cross36242852017-06-23 15:06:31 -07001196func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001197 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001198 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001199 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001200 }
1201 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001202 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001203 }
1204 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001205 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001206 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001207 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001208 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001209 }
Colin Cross16b23492016-01-06 14:41:07 -08001210 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001211 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001212 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001213 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001214 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001215 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001216 if c.fuzzer != nil {
1217 c.AddProperties(c.fuzzer.props()...)
1218 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001219 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001220 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001221 }
Justin Yun8effde42017-06-23 19:24:43 +09001222 if c.vndkdep != nil {
1223 c.AddProperties(c.vndkdep.props()...)
1224 }
Stephen Craneba090d12017-05-09 15:44:35 -07001225 if c.lto != nil {
1226 c.AddProperties(c.lto.props()...)
1227 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001228 if c.afdo != nil {
1229 c.AddProperties(c.afdo.props()...)
1230 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001231 if c.pgo != nil {
1232 c.AddProperties(c.pgo.props()...)
1233 }
Colin Crossca860ac2016-01-04 14:34:37 -08001234 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001235 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001236 }
Colin Crossc472d572015-03-17 15:06:21 -07001237
Colin Cross36242852017-06-23 15:06:31 -07001238 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001239 if c.bazelable {
1240 android.InitBazelModule(c)
1241 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001242 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001243 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001244
Colin Cross36242852017-06-23 15:06:31 -07001245 return c
Colin Crossc472d572015-03-17 15:06:21 -07001246}
1247
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001248// UseVndk() returns true if this module is built against VNDK.
1249// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001250func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001251 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001252}
1253
Colin Crossc511bc52020-04-07 16:50:32 +00001254func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001255 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1256 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001257}
1258
1259func (c *Module) UseSdk() bool {
1260 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001261 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001262 }
1263 return false
1264}
1265
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001266func (c *Module) isCoverageVariant() bool {
1267 return c.coverage.Properties.IsCoverageVariant
1268}
1269
Colin Cross95f1ca02020-10-29 20:47:22 -07001270func (c *Module) IsNdk(config android.Config) bool {
1271 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001272}
1273
Colin Cross127bb8b2020-12-16 16:46:01 -08001274func (c *Module) IsLlndk() bool {
1275 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001276}
1277
Colin Cross127bb8b2020-12-16 16:46:01 -08001278func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001279 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001280}
1281
Colin Cross1f3f1302021-04-26 18:37:44 -07001282func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001283 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001284 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001285}
1286
Colin Cross5271fea2021-04-27 13:06:04 -07001287func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1288 lib := moduleLibraryInterface(m)
1289 return lib != nil && (lib.hasVendorPublicLibrary())
1290}
1291
1292// IsVendorPublicLibrary returns true for vendor public libraries.
1293func (c *Module) IsVendorPublicLibrary() bool {
1294 return c.VendorProperties.IsVendorPublicLibrary
1295}
1296
Ivan Lozanof1868af2022-04-12 13:08:36 -04001297func (c *Module) IsVndkPrebuiltLibrary() bool {
1298 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1299 return true
1300 }
1301 return false
1302}
1303
1304func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1305 return c.Properties.SdkAndPlatformVariantVisibleToMake
1306}
1307
Ivan Lozanod7586b62021-04-01 09:49:36 -04001308func (c *Module) HasLlndkStubs() bool {
1309 lib := moduleLibraryInterface(c)
1310 return lib != nil && lib.hasLLNDKStubs()
1311}
1312
1313func (c *Module) StubsVersion() string {
1314 if lib, ok := c.linker.(versionedInterface); ok {
1315 return lib.stubsVersion()
1316 }
1317 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1318}
1319
Colin Cross127bb8b2020-12-16 16:46:01 -08001320// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1321// and does not set llndk.vendor_available: false.
1322func (c *Module) isImplementationForLLNDKPublic() bool {
1323 library, _ := c.library.(*libraryDecorator)
1324 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001325 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001326}
1327
Justin Yunfd9e8042020-12-23 18:23:14 +09001328// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001329func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001330 // Check if VNDK-core-private or VNDK-SP-private
1331 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001332 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001333 }
1334
1335 // Check if LLNDK-private
1336 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001337 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001338 }
1339
1340 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001341}
1342
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001343// IsVndk() returns true if this module has a vndk variant.
1344// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1345// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001346func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001347 if vndkdep := c.vndkdep; vndkdep != nil {
1348 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001349 }
1350 return false
1351}
1352
Yi Kong4ef54592022-02-14 20:00:10 +08001353func (c *Module) isAfdoCompile() bool {
1354 if afdo := c.afdo; afdo != nil {
Vinh Tran44cb78c2023-03-09 22:07:19 -05001355 return afdo.Properties.FdoProfilePath != nil
Yi Kong4ef54592022-02-14 20:00:10 +08001356 }
1357 return false
1358}
1359
Yi Kong7e53c572018-02-14 18:16:12 +08001360func (c *Module) isPgoCompile() bool {
1361 if pgo := c.pgo; pgo != nil {
1362 return pgo.Properties.PgoCompile
1363 }
1364 return false
1365}
1366
Yi Kongc702ebd2022-08-19 16:02:45 +08001367func (c *Module) isCfi() bool {
1368 if sanitize := c.sanitize; sanitize != nil {
1369 return Bool(sanitize.Properties.Sanitize.Cfi)
1370 }
1371 return false
1372}
1373
Yi Konged79fa32023-06-04 17:15:42 +09001374func (c *Module) isFuzzer() bool {
1375 if sanitize := c.sanitize; sanitize != nil {
1376 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1377 }
1378 return false
1379}
1380
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001381func (c *Module) isNDKStubLibrary() bool {
1382 if _, ok := c.compiler.(*stubDecorator); ok {
1383 return true
1384 }
1385 return false
1386}
1387
Ivan Lozanod7586b62021-04-01 09:49:36 -04001388func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001389 if vndkdep := c.vndkdep; vndkdep != nil {
1390 return vndkdep.isVndkSp()
1391 }
1392 return false
1393}
1394
Ivan Lozanof9e21722020-12-02 09:00:51 -05001395func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001396 if vndkdep := c.vndkdep; vndkdep != nil {
1397 return vndkdep.isVndkExt()
1398 }
1399 return false
1400}
1401
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001402func (c *Module) SubName() string {
1403 return c.Properties.SubName
1404}
1405
Ivan Lozano52767be2019-10-18 14:49:46 -07001406func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001407 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001408}
1409
Logan Chienf3511742017-10-31 18:04:35 +08001410func (c *Module) getVndkExtendsModuleName() string {
1411 if vndkdep := c.vndkdep; vndkdep != nil {
1412 return vndkdep.getVndkExtendsModuleName()
1413 }
1414 return ""
1415}
1416
Jiyong Park25fc6a92018-11-18 18:02:45 +09001417func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001418 if lib := c.library; lib != nil {
1419 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001420 }
1421 return false
1422}
1423
1424func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001425 if lib := c.library; lib != nil {
1426 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001427 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001428 return false
1429}
1430
Alan Stokes73feba32022-11-14 12:21:24 +00001431func (c *Module) IsStubsImplementationRequired() bool {
1432 if lib := c.library; lib != nil {
1433 return lib.isStubsImplementationRequired()
1434 }
1435 return false
1436}
1437
Colin Cross0477b422020-10-13 18:43:54 -07001438// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1439// the implementation. If it is an implementation library it returns its own name.
1440func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1441 name := ctx.OtherModuleName(c)
1442 if versioned, ok := c.linker.(versionedInterface); ok {
1443 name = versioned.implementationModuleName(name)
1444 }
1445 return name
1446}
1447
Martin Stjernholm2856c662020-12-02 15:03:42 +00001448// Similar to ImplementationModuleName, but uses the Make variant of the module
1449// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1450// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1451// under the premise that the prebuilt module overrides its source counterpart
1452// if it is exposed to Make).
1453func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1454 name := c.BaseModuleName()
1455 if versioned, ok := c.linker.(versionedInterface); ok {
1456 name = versioned.implementationModuleName(name)
1457 }
1458 return name
1459}
1460
Jiyong Park7d55b612021-06-11 17:22:09 +09001461func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001462 return Bool(c.Properties.Bootstrap)
1463}
1464
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001465func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001466 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1467 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1468 return false
1469 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001470 return c.linker != nil && c.linker.nativeCoverage()
1471}
1472
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001473func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001474 if p, ok := c.linker.(SnapshotInterface); ok {
1475 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001476 }
1477 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001478}
1479
Bill Peckham945441c2020-08-31 16:07:58 -07001480func (c *Module) ExcludeFromVendorSnapshot() bool {
1481 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1482}
1483
Jose Galmesf7294582020-11-13 12:07:36 -08001484func (c *Module) ExcludeFromRecoverySnapshot() bool {
1485 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1486}
1487
Jiyong Parkf1194352019-02-25 11:05:47 +09001488func isBionic(name string) bool {
1489 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001490 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001491 return true
1492 }
1493 return false
1494}
1495
Martin Stjernholm279de572019-09-10 23:18:20 +01001496func InstallToBootstrap(name string, config android.Config) bool {
Jingwen Chen29743c82023-01-25 17:49:46 +00001497 // NOTE: also update //build/bazel/rules/apex/cc.bzl#_installed_to_bootstrap
1498 // if this list is updated.
Florian Mayer95cd6db2023-03-23 17:48:07 -07001499 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001500 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001501 }
1502 return isBionic(name)
1503}
1504
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001505func (c *Module) XrefCcFiles() android.Paths {
1506 return c.kytheFiles
1507}
1508
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001509func (c *Module) isCfiAssemblySupportEnabled() bool {
1510 return c.sanitize != nil &&
1511 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1512}
1513
Inseob Kim800d1142021-06-14 12:03:51 +09001514func (c *Module) InstallInRoot() bool {
1515 return c.installer != nil && c.installer.installInRoot()
1516}
1517
Colin Crossca860ac2016-01-04 14:34:37 -08001518type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001519 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001520 moduleContextImpl
1521}
1522
Colin Cross37047f12016-12-13 17:06:13 -08001523type depsContext struct {
1524 android.BottomUpMutatorContext
1525 moduleContextImpl
1526}
1527
Colin Crossca860ac2016-01-04 14:34:37 -08001528type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001529 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001530 moduleContextImpl
1531}
1532
1533type moduleContextImpl struct {
1534 mod *Module
1535 ctx BaseModuleContext
1536}
1537
Colin Crossb98c8b02016-07-29 13:44:28 -07001538func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001539 return ctx.mod.toolchain(ctx.ctx)
1540}
1541
1542func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001543 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001544}
1545
1546func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001547 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001548}
1549
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001550func (ctx *moduleContextImpl) testBinary() bool {
1551 return ctx.mod.testBinary()
1552}
1553
Yi Kong56fc1b62022-09-06 16:24:00 +08001554func (ctx *moduleContextImpl) testLibrary() bool {
1555 return ctx.mod.testLibrary()
1556}
1557
Jiyong Park1d1119f2019-07-29 21:27:18 +09001558func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001559 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001560}
1561
Inseob Kim7f283f42020-06-01 21:53:49 +09001562func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001563 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001564}
1565
Inseob Kim1042d292020-06-01 23:23:05 +09001566func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001567 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001568}
1569
Jooyung Hanccce2f22020-03-07 03:45:53 +09001570func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001571 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001572}
1573
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001574func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001575 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001576}
1577
1578func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001579 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001580 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001581 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001582 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001583 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001584 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001585 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001586 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001587 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001588 }
1589 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001590}
1591
Jiyong Parkb35a8192020-08-10 15:59:36 +09001592func (ctx *moduleContextImpl) minSdkVersion() string {
1593 ver := ctx.mod.MinSdkVersion()
1594 if ver == "apex_inherit" && !ctx.isForPlatform() {
1595 ver = ctx.apexSdkVersion().String()
1596 }
1597 if ver == "apex_inherit" || ver == "" {
1598 ver = ctx.sdkVersion()
1599 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001600 // For crt objects, the meaning of min_sdk_version is very different from other types of
1601 // module. For them, min_sdk_version defines the oldest version that the build system will
1602 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1603 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1604 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001605 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1606 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1607 // support such an old version. The version is set to the later version in case when the
1608 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1609 // it's for an APEX.
1610 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1611 if ctx.isForPlatform() {
1612 ver = strconv.Itoa(android.FutureApiLevelInt)
1613 } else { // for apex
1614 ver = ctx.apexSdkVersion().String()
1615 if ver == "" { // in case when min_sdk_version was not set by the APEX
1616 ver = ctx.sdkVersion()
1617 }
1618 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001619 }
1620
Jiyong Parkb35a8192020-08-10 15:59:36 +09001621 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1622 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1623 minSdkVersionInt, err2 := strconv.Atoi(ver)
1624 if err == nil && err2 == nil {
1625 if sdkVersionInt < minSdkVersionInt {
1626 return strconv.Itoa(sdkVersionInt)
1627 }
1628 }
1629 return ver
1630}
1631
1632func (ctx *moduleContextImpl) isSdkVariant() bool {
1633 return ctx.mod.IsSdkVariant()
1634}
1635
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001636func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001637 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001638}
Justin Yun8effde42017-06-23 19:24:43 +09001639
Colin Cross95f1ca02020-10-29 20:47:22 -07001640func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1641 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001642}
1643
Colin Cross127bb8b2020-12-16 16:46:01 -08001644func (ctx *moduleContextImpl) IsLlndk() bool {
1645 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001646}
1647
Colin Cross127bb8b2020-12-16 16:46:01 -08001648func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1649 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001650}
1651
Colin Cross127bb8b2020-12-16 16:46:01 -08001652func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1653 return ctx.mod.isImplementationForLLNDKPublic()
1654}
1655
1656func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1657 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001658}
1659
Logan Chienf3511742017-10-31 18:04:35 +08001660func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001661 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001662}
1663
Yi Kong4ef54592022-02-14 20:00:10 +08001664func (ctx *moduleContextImpl) isAfdoCompile() bool {
1665 return ctx.mod.isAfdoCompile()
1666}
1667
Yi Kong7e53c572018-02-14 18:16:12 +08001668func (ctx *moduleContextImpl) isPgoCompile() bool {
1669 return ctx.mod.isPgoCompile()
1670}
1671
Yi Kongc702ebd2022-08-19 16:02:45 +08001672func (ctx *moduleContextImpl) isCfi() bool {
1673 return ctx.mod.isCfi()
1674}
1675
Yi Konged79fa32023-06-04 17:15:42 +09001676func (ctx *moduleContextImpl) isFuzzer() bool {
1677 return ctx.mod.isFuzzer()
1678}
1679
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001680func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1681 return ctx.mod.isNDKStubLibrary()
1682}
1683
Justin Yun8effde42017-06-23 19:24:43 +09001684func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001685 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001686}
1687
Ivan Lozanof9e21722020-12-02 09:00:51 -05001688func (ctx *moduleContextImpl) IsVndkExt() bool {
1689 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001690}
1691
Colin Cross5271fea2021-04-27 13:06:04 -07001692func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1693 return ctx.mod.IsVendorPublicLibrary()
1694}
1695
Vic Yangefd249e2018-11-12 20:19:56 -08001696func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001697 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001698}
1699
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001700func (ctx *moduleContextImpl) selectedStl() string {
1701 if stl := ctx.mod.stl; stl != nil {
1702 return stl.Properties.SelectedStl
1703 }
1704 return ""
1705}
1706
Ivan Lozanobd721262018-11-27 14:33:03 -08001707func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1708 return ctx.mod.linker.useClangLld(actx)
1709}
1710
Colin Crossce75d2c2016-10-06 16:12:58 -07001711func (ctx *moduleContextImpl) baseModuleName() string {
1712 return ctx.mod.ModuleBase.BaseModuleName()
1713}
1714
Logan Chienf3511742017-10-31 18:04:35 +08001715func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1716 return ctx.mod.getVndkExtendsModuleName()
1717}
1718
Logan Chiene274fc92019-12-03 11:18:32 -08001719func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001720 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001721}
1722
Colin Crosse07f2312020-08-13 11:24:56 -07001723func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001724 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001725}
1726
Dan Albertc8060532020-07-22 22:32:17 -07001727func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001728 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001729}
1730
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001731func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001732 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001733}
1734
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001735func (ctx *moduleContextImpl) nativeCoverage() bool {
1736 return ctx.mod.nativeCoverage()
1737}
1738
Colin Cross56a83212020-09-15 18:30:11 -07001739func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1740 return ctx.mod.DirectlyInAnyApex()
1741}
1742
Colin Cross95b07f22020-12-16 11:06:50 -08001743func (ctx *moduleContextImpl) isPreventInstall() bool {
1744 return ctx.mod.Properties.PreventInstall
1745}
1746
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001747func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1748 shared := &ctx.mod.sharedFlags
1749 if shared.flagsMap == nil {
1750 shared.numSharedFlags = 0
1751 shared.flagsMap = make(map[string]string)
1752 }
1753 return shared
1754}
1755
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001756func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1757 return ctx.mod.isCfiAssemblySupportEnabled()
1758}
1759
Colin Cross635c3b02016-05-18 15:37:25 -07001760func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001761 return &Module{
1762 hod: hod,
1763 multilib: multilib,
1764 }
1765}
1766
Colin Cross635c3b02016-05-18 15:37:25 -07001767func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001768 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001769 module.features = []feature{
1770 &tidyFeature{},
1771 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001772 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001773 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001774 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001775 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001776 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001777 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001778 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001779 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001780 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001781 return module
1782}
1783
Colin Crossce75d2c2016-10-06 16:12:58 -07001784func (c *Module) Prebuilt() *android.Prebuilt {
1785 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1786 return p.prebuilt()
1787 }
1788 return nil
1789}
1790
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001791func (c *Module) IsPrebuilt() bool {
1792 return c.Prebuilt() != nil
1793}
1794
Colin Crossce75d2c2016-10-06 16:12:58 -07001795func (c *Module) Name() string {
1796 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001797 if p, ok := c.linker.(interface {
1798 Name(string) string
1799 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001800 name = p.Name(name)
1801 }
1802 return name
1803}
1804
Alex Light3d673592019-01-18 14:37:31 -08001805func (c *Module) Symlinks() []string {
1806 if p, ok := c.installer.(interface {
1807 symlinkList() []string
1808 }); ok {
1809 return p.symlinkList()
1810 }
1811 return nil
1812}
1813
Roland Levillainf89cd092019-07-29 16:22:59 +01001814func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1815 test, ok := c.linker.(testPerSrc)
1816 return ok && test.isAllTestsVariation()
1817}
1818
Chris Parsons216e10a2020-07-09 17:12:52 -04001819func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001820 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001821 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001822 }); ok {
1823 return p.dataPaths()
1824 }
1825 return nil
1826}
1827
Ivan Lozanof1868af2022-04-12 13:08:36 -04001828func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001829 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1830 // "current", it will append the VNDK version to the name suffix.
1831 var vndkVersion string
1832 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001833 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001834 if c.ProductSpecific() {
1835 // If the module is product specific with 'product_specific: true',
1836 // do not add a name suffix because it is a base module.
1837 return ""
1838 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001839 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001840 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001841 } else {
1842 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001843 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001844 }
1845 if vndkVersion == "current" {
1846 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1847 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001848 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001849 // add version suffix only if the module is using different vndk version than the
1850 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001851 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001852 }
1853 return nameSuffix
1854}
1855
Ivan Lozanof1868af2022-04-12 13:08:36 -04001856func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1857 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001858
1859 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001860 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001861 }
1862
Colin Cross127bb8b2020-12-16 16:46:01 -08001863 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001864 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001865 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1866 // added for product variant only when we have vendor and product variants with core
1867 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001868 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001869 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001870 subName += vendorPublicLibrarySuffix
1871 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001872 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1873 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001874 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001875 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001876 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001877 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001878 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001879 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001880 subName += RecoverySuffix
1881 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1882 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001883 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001884 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001885 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001886 } else if c.IsStubs() && c.IsSdkVariant() {
1887 // Public API surface (NDK)
1888 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1889 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001890 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001891
1892 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001893}
1894
Chris Parsonsf874e462022-05-10 13:50:12 -04001895var _ android.MixedBuildBuildable = (*Module)(nil)
1896
1897func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001898 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001899 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001900 // cc_library is a special case in bp2build; two targets are generated -- one for each
1901 // of the shared and static variants. The shared variant keeps the module name, but the
1902 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001903 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1904 } else {
1905 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001906 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001907 labelNoPrebuilt := bazelModuleLabel
1908 if c.IsPrebuilt() {
1909 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1910 }
1911 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001912}
1913
1914func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1915 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1916}
1917
Jingwen Chen3952a902022-12-12 12:20:58 +00001918// IsMixedBuildSupported returns true if the module should be analyzed by Bazel
Jingwen Chena485d092023-04-20 12:34:08 +00001919// in any of the --bazel-mode(s).
Chris Parsonsf874e462022-05-10 13:50:12 -04001920func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
Yu Liu8860c6c2023-06-07 12:43:26 -07001921 if !allEnabledSanitizersSupportedByBazel(ctx, c) {
Sam Delmericoef69d472023-04-18 17:32:43 -04001922 //TODO(b/278772861) support sanitizers in Bazel rules
Yu Liue4312402023-01-18 09:15:31 -08001923 return false
1924 }
Sam Delmericoef69d472023-04-18 17:32:43 -04001925 return c.bazelHandler != nil
1926}
1927
Yu Liu8860c6c2023-06-07 12:43:26 -07001928func allEnabledSanitizersSupportedByBazel(ctx android.BaseModuleContext, c *Module) bool {
Sam Delmericoef69d472023-04-18 17:32:43 -04001929 if c.sanitize == nil {
1930 return true
1931 }
Yu Liue4312402023-01-18 09:15:31 -08001932 sanitizeProps := &c.sanitize.Properties.SanitizeMutated
Sam Delmericoef69d472023-04-18 17:32:43 -04001933
1934 unsupportedSanitizers := []*bool{
1935 sanitizeProps.Safestack,
Sam Delmericoef69d472023-04-18 17:32:43 -04001936 sanitizeProps.Scudo,
1937 BoolPtr(len(c.sanitize.Properties.Sanitize.Recover) > 0),
Sam Delmericoef69d472023-04-18 17:32:43 -04001938 }
1939 for _, san := range unsupportedSanitizers {
1940 if Bool(san) {
1941 return false
1942 }
1943 }
1944
1945 for _, san := range Sanitizers {
1946 if san == intOverflow {
1947 // TODO(b/261058727): enable mixed builds for all modules with UBSan
1948 // Currently we can only support ubsan when minimum runtime is used.
1949 ubsanEnabled := Bool(sanitizeProps.Integer_overflow) || len(sanitizeProps.Misc_undefined) > 0
Yu Liu8860c6c2023-06-07 12:43:26 -07001950 if !ubsanEnabled || c.MinimalRuntimeNeeded() {
1951 continue
Sam Delmericoef69d472023-04-18 17:32:43 -04001952 }
Yu Liu95497dc2023-05-25 11:15:07 -07001953 } else if san == cfi {
Yu Liu8860c6c2023-06-07 12:43:26 -07001954 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1955 // Only allow cfi if this is an apex variant
1956 if !apexInfo.IsForPlatform() {
1957 continue
1958 }
1959 }
1960 if c.sanitize.isSanitizerEnabled(san) {
Sam Delmericoef69d472023-04-18 17:32:43 -04001961 return false
1962 }
1963 }
1964
1965 return true
Yu Liue4312402023-01-18 09:15:31 -08001966}
1967
1968func GetApexConfigKey(ctx android.BaseModuleContext) *android.ApexConfigKey {
1969 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1970 if !apexInfo.IsForPlatform() {
Yu Liubfb23622023-02-22 10:42:15 -08001971 if !ctx.Config().BazelContext.IsModuleDclaAllowed(ctx.Module().Name()) {
1972 return nil
1973 }
Yu Liue4312402023-01-18 09:15:31 -08001974 apexKey := android.ApexConfigKey{
1975 WithinApex: true,
1976 ApexSdkVersion: findApexSdkVersion(ctx, apexInfo).String(),
Spandan Das40b79f82023-06-25 20:56:06 +00001977 ApiDomain: findApiDomain(apexInfo),
Yu Liue4312402023-01-18 09:15:31 -08001978 }
1979 return &apexKey
1980 }
1981
1982 return nil
Chris Parsonsf874e462022-05-10 13:50:12 -04001983}
1984
Spandan Das40b79f82023-06-25 20:56:06 +00001985// Returns the api domain of a module for an apexInfo group
1986// Input:
1987// ai.InApexModules: [com.android.foo, test_com.android.foo, com.google.android.foo]
1988// Return:
1989// com.android.foo
1990
1991// If a module is included in multiple api domains (collated by min_sdk_version), it will return
1992// the first match. The other matches have the same build actions since they share a min_sdk_version, so returning
1993// the first match is fine.
1994func findApiDomain(ai android.ApexInfo) string {
1995 // Remove any test apexes
1996 matches, _ := android.FilterList(ai.InApexModules, ai.TestApexes)
1997 // Remove any google apexes. Rely on naming convention.
1998 pred := func(s string) bool { return !strings.HasPrefix(s, "com.google") }
1999 matches = android.FilterListPred(matches, pred)
2000 if len(matches) > 0 {
2001 // Return the first match
2002 return android.SortedUniqueStrings(matches)[0]
2003 } else {
2004 // No apex in the tree has a dependency on this module
2005 return ""
2006 }
2007}
2008
Chris Parsonsf874e462022-05-10 13:50:12 -04002009func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
2010 bazelModuleLabel := c.getBazelModuleLabel(ctx)
Chris Parsonsf874e462022-05-10 13:50:12 -04002011 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
2012
2013 c.Properties.SubName = GetSubnameProperty(ctx, c)
2014 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2015 if !apexInfo.IsForPlatform() {
2016 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05002017 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05002018
Chris Parsonsf874e462022-05-10 13:50:12 -04002019 c.makeLinkType = GetMakeLinkType(ctx, c)
2020
2021 mctx := &moduleContext{
2022 ModuleContext: ctx,
2023 moduleContextImpl: moduleContextImpl{
2024 mod: c,
2025 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05002026 }
Chris Parsonsf874e462022-05-10 13:50:12 -04002027 mctx.ctx = mctx
2028
Jingwen Chen3952a902022-12-12 12:20:58 +00002029 // TODO(b/244432500): Get the tradefed config from the bazel target instead
2030 // of generating it with Soong.
Chris Parsonsf874e462022-05-10 13:50:12 -04002031 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002032}
2033
Sam Delmerico75dbca22023-04-20 13:13:25 +00002034func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
2035 ctx := &moduleContext{
2036 ModuleContext: actx,
2037 moduleContextImpl: moduleContextImpl{
2038 mod: c,
2039 },
2040 }
2041 ctx.ctx = ctx
2042 return ctx
2043}
2044
Spandan Das20fce2d2023-04-12 17:21:39 +00002045// TODO (b/277651159): Remove this allowlist
2046var (
2047 skipStubLibraryMultipleApexViolation = map[string]bool{
2048 "libclang_rt.asan": true,
2049 "libclang_rt.hwasan": true,
2050 // runtime apex
2051 "libc": true,
2052 "libc_hwasan": true,
2053 "libdl_android": true,
2054 "libm": true,
2055 "libdl": true,
2056 // art apex
2057 "libandroidio": true,
2058 "libdexfile": true,
2059 "libnativebridge": true,
2060 "libnativehelper": true,
2061 "libnativeloader": true,
2062 "libsigchain": true,
2063 }
2064)
2065
2066// Returns true if a stub library could be installed in multiple apexes
2067func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
2068 // If this is not an apex variant, no check necessary
2069 if !c.InAnyApex() {
2070 return false
2071 }
2072 // If this is not a stub library, no check necessary
2073 if !c.HasStubsVariants() {
2074 return false
2075 }
2076 // Skip the allowlist
2077 // Use BaseModuleName so that this matches prebuilts.
2078 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
2079 return false
2080 }
2081
2082 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
2083 // Stub libraries should not have more than one apex_available
2084 if len(aaWithoutTestApexes) > 1 {
2085 return true
2086 }
2087 // Stub libraries should not use the wildcard
2088 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
2089 return true
2090 }
2091 // Default: no violation
2092 return false
2093}
2094
Chris Parsons8d6e4332021-02-22 16:13:50 -05002095func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05002096 // Handle the case of a test module split by `test_per_src` mutator.
2097 //
2098 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
2099 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
2100 // module and return early, as this module does not produce an output file per se.
2101 if c.IsTestPerSrcAllTestsVariation() {
2102 c.outputFile = android.OptionalPath{}
2103 return
2104 }
2105
Ivan Lozanof1868af2022-04-12 13:08:36 -04002106 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002107 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2108 if !apexInfo.IsForPlatform() {
2109 c.hideApexVariantFromMake = true
2110 }
2111
Chris Parsonseefc9e62021-04-02 17:36:47 -04002112 c.makeLinkType = GetMakeLinkType(actx, c)
2113
Sam Delmerico75dbca22023-04-20 13:13:25 +00002114 ctx := moduleContextFromAndroidModuleContext(actx, c)
Colin Crossca860ac2016-01-04 14:34:37 -08002115
Colin Crossf18e1102017-11-16 14:33:08 -08002116 deps := c.depsToPaths(ctx)
2117 if ctx.Failed() {
2118 return
2119 }
2120
Spandan Das20fce2d2023-04-12 17:21:39 +00002121 if c.stubLibraryMultipleApexViolation(actx) {
2122 actx.PropertyErrorf("apex_available",
2123 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
2124 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002125 if c.Properties.Clang != nil && *c.Properties.Clang == false {
2126 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00002127 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
2128 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002129 }
2130
Colin Crossca860ac2016-01-04 14:34:37 -08002131 flags := Flags{
2132 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002133 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002134 }
Colin Crossca860ac2016-01-04 14:34:37 -08002135 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002136 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002137 }
2138 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002139 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002140 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002141 if c.stl != nil {
2142 flags = c.stl.flags(ctx, flags)
2143 }
Colin Cross16b23492016-01-06 14:41:07 -08002144 if c.sanitize != nil {
2145 flags = c.sanitize.flags(ctx, flags)
2146 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002147 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002148 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002149 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002150 if c.fuzzer != nil {
2151 flags = c.fuzzer.flags(ctx, flags)
2152 }
Stephen Craneba090d12017-05-09 15:44:35 -07002153 if c.lto != nil {
2154 flags = c.lto.flags(ctx, flags)
2155 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002156 if c.afdo != nil {
2157 flags = c.afdo.flags(ctx, flags)
2158 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002159 if c.pgo != nil {
2160 flags = c.pgo.flags(ctx, flags)
2161 }
Colin Crossca860ac2016-01-04 14:34:37 -08002162 for _, feature := range c.features {
2163 flags = feature.flags(ctx, flags)
2164 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002165 if ctx.Failed() {
2166 return
2167 }
2168
Colin Cross4af21ed2019-11-04 09:37:55 -08002169 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2170 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2171 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002172
Colin Cross4af21ed2019-11-04 09:37:55 -08002173 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002174
2175 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002176 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002177 }
2178 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002179 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002180 }
2181
Colin Cross3e5e7782022-06-17 22:17:05 +00002182 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2183
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002184 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002185 // We need access to all the flags seen by a source file.
2186 if c.sabi != nil {
2187 flags = c.sabi.flags(ctx, flags)
2188 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002189
Colin Cross4af21ed2019-11-04 09:37:55 -08002190 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002191
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002192 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002193 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002194 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002195 if ctx.Failed() {
2196 return
2197 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002198 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002199 c.objFiles = objs.objFiles
2200 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002201 }
2202
Colin Crossca860ac2016-01-04 14:34:37 -08002203 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002204 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002205 if ctx.Failed() {
2206 return
2207 }
Colin Cross635c3b02016-05-18 15:37:25 -07002208 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002209
Chris Parsons94a0bba2021-06-04 15:03:47 -04002210 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002211
Jose Galmes6f843bc2020-12-11 13:36:29 -08002212 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2213 // RECOVERY_SNAPSHOT_VERSION is current.
2214 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002215 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002216 i.collectHeadersForSnapshot(ctx)
2217 }
2218 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002219 }
Colin Cross5049f022015-03-18 13:28:46 -07002220
Chris Parsons94a0bba2021-06-04 15:03:47 -04002221 c.maybeInstall(ctx, apexInfo)
2222}
2223
2224func (c *Module) maybeUnhideFromMake() {
2225 // If a lib is directly included in any of the APEXes or is not available to the
2226 // platform (which is often the case when the stub is provided as a prebuilt),
2227 // unhide the stubs variant having the latest version gets visible to make. In
2228 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2229 // force anything in the make world to link against the stubs library. (unless it
2230 // is explicitly referenced via .bootstrap suffix or the module is marked with
2231 // 'bootstrap: true').
2232 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2233 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2234 c.IsStubs() && !c.InVendorRamdisk() {
2235 c.Properties.HideFromMake = false // unhide
2236 // Note: this is still non-installable
2237 }
2238}
2239
Jingwen Chen3952a902022-12-12 12:20:58 +00002240// maybeInstall is called at the end of both GenerateAndroidBuildActions and
2241// ProcessBazelQueryResponse to run the install hooks for installable modules,
2242// like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002243func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002244 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002245 // If the module has been specifically configure to not be installed then
2246 // hide from make as otherwise it will break when running inside make
2247 // as the output path to install will not be specified. Not all uninstallable
2248 // modules can be hidden from make as some are needed for resolving make side
2249 // dependencies.
2250 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002251 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002252 c.SkipInstall()
2253 }
2254
2255 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2256 // to allow using the outputs in a genrule.
2257 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002258 c.installer.install(ctx, c.outputFile.Path())
2259 if ctx.Failed() {
2260 return
Colin Crossca860ac2016-01-04 14:34:37 -08002261 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002262 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002263}
2264
Sam Delmerico5fb794a2023-01-27 16:01:37 -05002265func (c *Module) setAndroidMkVariablesFromCquery(info cquery.CcAndroidMkInfo) {
2266 c.Properties.AndroidMkSharedLibs = info.LocalSharedLibs
2267 c.Properties.AndroidMkStaticLibs = info.LocalStaticLibs
2268 c.Properties.AndroidMkWholeStaticLibs = info.LocalWholeStaticLibs
2269}
2270
Colin Cross0ea8ba82019-06-06 14:33:29 -07002271func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002272 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002273 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002274 }
Colin Crossca860ac2016-01-04 14:34:37 -08002275 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002276}
2277
Colin Crossca860ac2016-01-04 14:34:37 -08002278func (c *Module) begin(ctx BaseModuleContext) {
2279 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002280 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002281 }
Colin Crossca860ac2016-01-04 14:34:37 -08002282 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002283 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002284 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002285 if c.stl != nil {
2286 c.stl.begin(ctx)
2287 }
Colin Cross16b23492016-01-06 14:41:07 -08002288 if c.sanitize != nil {
2289 c.sanitize.begin(ctx)
2290 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002291 if c.coverage != nil {
2292 c.coverage.begin(ctx)
2293 }
Stephen Craneba090d12017-05-09 15:44:35 -07002294 if c.lto != nil {
2295 c.lto.begin(ctx)
2296 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002297 if c.pgo != nil {
2298 c.pgo.begin(ctx)
2299 }
Dan Albert92fe7402020-07-15 13:33:30 -07002300 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002301 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002302 if err != nil {
2303 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002304 c.Properties.Sdk_version = nil
2305 } else {
2306 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002307 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002308 }
Colin Crossca860ac2016-01-04 14:34:37 -08002309}
2310
Colin Cross37047f12016-12-13 17:06:13 -08002311func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002312 deps := Deps{}
2313
2314 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002315 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002316 }
2317 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002318 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002319 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002320 if c.stl != nil {
2321 deps = c.stl.deps(ctx, deps)
2322 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002323 if c.coverage != nil {
2324 deps = c.coverage.deps(ctx, deps)
2325 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002326
Colin Crossb6715442017-10-24 11:13:31 -07002327 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2328 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2329 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2330 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2331 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2332 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002333 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002334
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002335 for _, lib := range deps.ReexportSharedLibHeaders {
2336 if !inList(lib, deps.SharedLibs) {
2337 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2338 }
2339 }
2340
2341 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002342 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2343 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 -07002344 }
2345 }
2346
Colin Cross5950f382016-12-13 12:50:57 -08002347 for _, lib := range deps.ReexportHeaderLibHeaders {
2348 if !inList(lib, deps.HeaderLibs) {
2349 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2350 }
2351 }
2352
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002353 for _, gen := range deps.ReexportGeneratedHeaders {
2354 if !inList(gen, deps.GeneratedHeaders) {
2355 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2356 }
2357 }
2358
Colin Crossc99deeb2016-04-11 15:06:20 -07002359 return deps
2360}
2361
Dan Albert7e9d2952016-08-04 13:02:36 -07002362func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002363 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002364 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002365 moduleContextImpl: moduleContextImpl{
2366 mod: c,
2367 },
2368 }
2369 ctx.ctx = ctx
2370
Vinh Tran44cb78c2023-03-09 22:07:19 -05002371 if !actx.Host() || !ctx.static() || ctx.staticBinary() {
2372 c.afdo.addDep(ctx, actx)
2373 }
2374
Colin Crossca860ac2016-01-04 14:34:37 -08002375 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002376}
2377
Jiyong Park7ed9de32018-10-15 22:25:07 +09002378// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002379func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002380 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2381 version := name[sharp+1:]
2382 libname := name[:sharp]
2383 return libname, version
2384 }
2385 return name, ""
2386}
2387
Dan Albert92fe7402020-07-15 13:33:30 -07002388func GetCrtVariations(ctx android.BottomUpMutatorContext,
2389 m LinkableInterface) []blueprint.Variation {
2390 if ctx.Os() != android.Android {
2391 return nil
2392 }
2393 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002394 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2395 minSdkVersion := m.MinSdkVersion()
2396 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2397 minSdkVersion = m.SdkVersion()
2398 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002399 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2400 if err != nil {
2401 ctx.PropertyErrorf("min_sdk_version", err.Error())
2402 }
Colin Cross363ec762023-01-13 13:45:14 -08002403
2404 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002405 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002406 if apiLevel.LessThan(minApiForArch) {
2407 apiLevel = minApiForArch
2408 }
2409
Dan Albert92fe7402020-07-15 13:33:30 -07002410 return []blueprint.Variation{
2411 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002412 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002413 }
2414 }
2415 return []blueprint.Variation{
2416 {Mutator: "sdk", Variation: ""},
2417 }
2418}
2419
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002420func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2421 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002422
2423 variations = append([]blueprint.Variation(nil), variations...)
2424
Liz Kammer23942242022-04-08 15:41:00 -04002425 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002426 // Version is explicitly specified. i.e. libFoo#30
2427 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002428 if tag, ok := depTag.(libraryDependencyTag); ok {
2429 tag.explicitlyVersioned = true
2430 } else {
2431 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2432 }
Colin Crosse7257d22020-09-24 09:56:18 -07002433 }
Colin Crosse7257d22020-09-24 09:56:18 -07002434
Colin Cross0de8a1e2020-09-18 14:15:30 -07002435 if far {
2436 ctx.AddFarVariationDependencies(variations, depTag, name)
2437 } else {
2438 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002439 }
2440}
2441
Kiyoung Kim487689e2022-07-26 09:48:22 +09002442func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2443 apiImportInfo := multitree.ApiImportInfo{}
2444
2445 if c.Device() {
2446 var apiImportModule []blueprint.Module
2447 if actx.OtherModuleExists("api_imports") {
2448 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2449 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2450 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2451 apiImportInfo = apiInfo
2452 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2453 }
2454 }
2455 }
2456
2457 return apiImportInfo
2458}
2459
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002460func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002461 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002462 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002463 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002464 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2465 // between the modules in the snapshot and the snapshot itself.
2466 var snapshotModule []blueprint.Module
2467 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2468 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2469 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2470 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2471 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002472 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002473 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2474 *snapshotInfo = &snapshot
2475 // republish the snapshot for use in later mutators on this module
2476 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002477 }
2478 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002479 if *snapshotInfo == nil {
2480 *snapshotInfo = &SnapshotInfo{}
2481 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002482 return **snapshotInfo
2483}
2484
Kiyoung Kim487689e2022-07-26 09:48:22 +09002485func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2486 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002487 return snapshot
2488 }
2489
2490 return lib
2491}
2492
2493// RewriteLibs takes a list of names of shared libraries and scans it for three types
2494// of names:
2495//
2496// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002497//
2498// For each of these, it adds the name of the prebuilt module (which will be in
2499// prebuilts/ndk) to the list of nonvariant libs.
2500//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002501// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002502//
2503// For each of these, it adds the name of the ndk_library module to the list of
2504// variant libs.
2505//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002506// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002507//
2508// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002509//
2510// The caller can then know to add the variantLibs dependencies differently from the
2511// nonvariantLibs
2512func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2513 variantLibs = []string{}
2514
2515 nonvariantLibs = []string{}
2516 for _, entry := range list {
2517 // strip #version suffix out
2518 name, _ := StubsLibNameAndVersion(entry)
2519 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002520 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002521 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2522 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2523 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002524 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002525 } else {
2526 // put name#version back
2527 nonvariantLibs = append(nonvariantLibs, entry)
2528 }
2529 }
2530 return nonvariantLibs, variantLibs
2531}
2532
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002533func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2534 nonVariantLibs := []string{}
2535 variantLibs := []string{}
2536
2537 for _, lib := range libs {
2538 replaceLibName := GetReplaceModuleName(lib, replaceList)
2539 if replaceLibName == lib {
2540 // Do not handle any libs which are not in API imports
2541 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2542 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2543 variantLibs = append(variantLibs, replaceLibName)
2544 } else {
2545 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2546 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002547 }
2548
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002549 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002550}
2551
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002552func (c *Module) shouldUseApiSurface() bool {
2553 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2554 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2555 // LLNDK Variant
2556 return true
2557 }
2558
2559 if c.Properties.IsSdkVariant {
2560 // NDK Variant
2561 return true
2562 }
2563
2564 if c.isImportedApiLibrary() {
2565 // API Library should depend on API headers
2566 return true
2567 }
2568 }
2569
2570 return false
2571}
2572
Colin Cross1e676be2016-10-12 14:38:15 -07002573func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002574 if !c.Enabled() {
2575 return
2576 }
2577
Colin Cross37047f12016-12-13 17:06:13 -08002578 ctx := &depsContext{
2579 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002580 moduleContextImpl: moduleContextImpl{
2581 mod: c,
2582 },
2583 }
2584 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002585
Colin Crossc99deeb2016-04-11 15:06:20 -07002586 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002587 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002588
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002589 apiNdkLibs := []string{}
2590 apiLateNdkLibs := []string{}
2591
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002592 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002593 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2594 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2595 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2596 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2597 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002598 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002599
Yo Chiang219968c2020-09-22 18:45:04 +08002600 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2601
Colin Crosse0edaf92021-01-11 17:31:17 -08002602 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002603
Dan Albert914449f2016-06-17 16:45:24 -07002604 variantNdkLibs := []string{}
2605 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002606 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002607 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2608 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2609 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002610
2611 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002612 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002613 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002614 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002615
Colin Cross32ec36c2016-12-15 07:39:51 -08002616 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002617 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002618 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002619 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002620 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002621
Kiyoung Kim51279d32022-08-24 14:10:46 +09002622 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002623 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002624 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2625 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002626 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002627
Spandan Das73bcafc2022-08-18 23:26:00 +00002628 if c.isNDKStubLibrary() {
2629 // ndk_headers do not have any variations
2630 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002631 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002632 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002633 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002634 } else {
2635 actx.AddVariationDependencies(nil, depTag, lib)
2636 }
2637 }
2638
Dan Albertf1d14c72020-07-30 14:32:55 -07002639 if c.isNDKStubLibrary() {
2640 // NDK stubs depend on their implementation because the ABI dumps are
2641 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002642
Spandan Das8b08aea2023-03-14 19:29:34 +00002643 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2644 c.ImageVariation(),
2645 blueprint.Variation{Mutator: "link", Variation: "shared"},
2646 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002647 }
2648
Jiyong Park5d1598f2019-02-25 22:14:17 +09002649 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002650 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002651
Kiyoung Kim487689e2022-07-26 09:48:22 +09002652 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002653
Jiyong Park5d1598f2019-02-25 22:14:17 +09002654 actx.AddVariationDependencies([]blueprint.Variation{
2655 {Mutator: "link", Variation: "static"},
2656 }, depTag, lib)
2657 }
2658
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002659 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002660 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002661 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002662 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002663 }
Jiyong Parke3867542020-12-03 17:28:25 +09002664 if inList(lib, deps.ExcludeLibsForApex) {
2665 depTag.excludeInApex = true
2666 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002667
Kiyoung Kim487689e2022-07-26 09:48:22 +09002668 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002669
Dan Willemsen59339a22018-07-22 21:18:45 -07002670 actx.AddVariationDependencies([]blueprint.Variation{
2671 {Mutator: "link", Variation: "static"},
2672 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002673 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002674
Jooyung Han75568392020-03-20 04:29:24 +09002675 // staticUnwinderDep is treated as staticDep for Q apexes
2676 // so that native libraries/binaries are linked with static unwinder
2677 // because Q libc doesn't have unwinder APIs
2678 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002679 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002680 actx.AddVariationDependencies([]blueprint.Variation{
2681 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002682 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002683 }
2684
Jiyong Park7ed9de32018-10-15 22:25:07 +09002685 // shared lib names without the #version suffix
2686 var sharedLibNames []string
2687
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002688 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002689 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002690 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002691 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002692 }
Jiyong Parke3867542020-12-03 17:28:25 +09002693 if inList(lib, deps.ExcludeLibsForApex) {
2694 depTag.excludeInApex = true
2695 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002696
Jiyong Park73c54ee2019-10-22 20:31:18 +09002697 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002698 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2699 name = apiLibraryName
2700 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002701 sharedLibNames = append(sharedLibNames, name)
2702
Colin Crosse7257d22020-09-24 09:56:18 -07002703 variations := []blueprint.Variation{
2704 {Mutator: "link", Variation: "shared"},
2705 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002706
2707 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2708 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2709 }
2710
2711 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2712 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2713 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002714 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002715
Colin Crossfe9acfe2021-06-14 16:13:03 -07002716 for _, lib := range deps.LateStaticLibs {
2717 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2718 actx.AddVariationDependencies([]blueprint.Variation{
2719 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002720 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002721 }
2722
Colin Cross3e5e7782022-06-17 22:17:05 +00002723 for _, lib := range deps.UnexportedStaticLibs {
2724 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2725 actx.AddVariationDependencies([]blueprint.Variation{
2726 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002727 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002728 }
2729
Jiyong Park7ed9de32018-10-15 22:25:07 +09002730 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002731 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002732 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2733 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2734 // linking against both the stubs lib and the non-stubs lib at the same time.
2735 continue
2736 }
Colin Cross6e511a92020-07-27 21:26:48 -07002737 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002738 variations := []blueprint.Variation{
2739 {Mutator: "link", Variation: "shared"},
2740 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002741 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002742 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002743
Dan Willemsen59339a22018-07-22 21:18:45 -07002744 actx.AddVariationDependencies([]blueprint.Variation{
2745 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002746 }, dataLibDepTag, deps.DataLibs...)
2747
Colin Crossc8caa062021-09-24 16:50:14 -07002748 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2749
Chris Parsons79d66a52020-06-05 17:26:16 -04002750 actx.AddVariationDependencies([]blueprint.Variation{
2751 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002752 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002753
Colin Cross68861832016-07-08 10:41:41 -07002754 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002755
2756 for _, gen := range deps.GeneratedHeaders {
2757 depTag := genHeaderDepTag
2758 if inList(gen, deps.ReexportGeneratedHeaders) {
2759 depTag = genHeaderExportDepTag
2760 }
2761 actx.AddDependency(c, depTag, gen)
2762 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002763
Dan Albert92fe7402020-07-15 13:33:30 -07002764 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002765 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002766 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002767 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002768 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002769 }
Colin Crossc465efd2021-06-11 18:00:04 -07002770 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002771 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002772 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002773 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002774 if deps.DynamicLinker != "" {
2775 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002776 }
Dan Albert914449f2016-06-17 16:45:24 -07002777
2778 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002779
2780 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002781 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002782 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002783 {Mutator: "link", Variation: "shared"},
2784 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002785 actx.AddVariationDependencies([]blueprint.Variation{
2786 {Mutator: "version", Variation: version},
2787 {Mutator: "link", Variation: "shared"},
2788 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002789
2790 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002791 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002792 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002793 {Mutator: "link", Variation: "shared"},
2794 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002795 actx.AddVariationDependencies([]blueprint.Variation{
2796 {Mutator: "version", Variation: version},
2797 {Mutator: "link", Variation: "shared"},
2798 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002799
2800 if vndkdep := c.vndkdep; vndkdep != nil {
2801 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002802 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002803 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002804 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002805 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002806 }
2807 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002808
Vinh Tran367d89d2023-04-28 11:21:25 -04002809 if len(deps.AidlLibs) > 0 {
2810 actx.AddDependency(
2811 c,
2812 aidlLibraryTag,
2813 deps.AidlLibs...,
2814 )
2815 }
2816
Kiyoung Kimee58c932022-10-25 22:59:41 +09002817 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002818}
Colin Cross21b9a242015-03-24 14:15:58 -07002819
Colin Crosse40b4ea2018-10-02 22:25:58 -07002820func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002821 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2822 c.beginMutator(ctx)
2823 }
2824}
2825
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002826// Whether a module can link to another module, taking into
2827// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002828func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002829 tag blueprint.DependencyTag) {
2830
2831 switch t := tag.(type) {
2832 case dependencyTag:
2833 if t != vndkExtDepTag {
2834 return
2835 }
2836 case libraryDependencyTag:
2837 default:
2838 return
2839 }
2840
Ivan Lozanof9e21722020-12-02 09:00:51 -05002841 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002842 // Host code is not restricted
2843 return
2844 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002845
2846 // VNDK is cc.Module supported only for now.
2847 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002848 // Though allowed dependency is limited by the image mutator,
2849 // each vendor and product module needs to check link-type
2850 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002851 if ccTo, ok := to.(*Module); ok {
2852 if ccFrom.vndkdep != nil {
2853 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2854 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002855 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002856 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002857 }
2858 return
2859 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002860 // TODO(b/244244438) : Remove this once all variants are implemented
2861 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2862 return
2863 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002864 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002865 // Platform code can link to anything
2866 return
2867 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002868 if from.InRamdisk() {
2869 // Ramdisk code is not NDK
2870 return
2871 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002872 if from.InVendorRamdisk() {
2873 // Vendor ramdisk code is not NDK
2874 return
2875 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002876 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002877 // Recovery code is not NDK
2878 return
2879 }
Colin Cross31076b32020-10-23 17:22:06 -07002880 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002881 if c.NdkPrebuiltStl() {
2882 // These are allowed, but they don't set sdk_version
2883 return
2884 }
2885 if c.StubDecorator() {
2886 // These aren't real libraries, but are the stub shared libraries that are included in
2887 // the NDK.
2888 return
2889 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002890 if c.isImportedApiLibrary() {
2891 // Imported library from the API surface is a stub library built against interface definition.
2892 return
2893 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002894 }
Logan Chien834b9a62019-01-14 15:39:03 +08002895
Ivan Lozano52767be2019-10-18 14:49:46 -07002896 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002897 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2898 // to link to libc++ (non-NDK and without sdk_version).
2899 return
2900 }
2901
Ivan Lozano52767be2019-10-18 14:49:46 -07002902 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002903 // NDK code linking to platform code is never okay.
2904 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002905 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002906 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002907 }
2908
2909 // At this point we know we have two NDK libraries, but we need to
2910 // check that we're not linking against anything built against a higher
2911 // API level, as it is only valid to link against older or equivalent
2912 // APIs.
2913
Inseob Kim01a28722018-04-11 09:48:45 +09002914 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002915 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002916 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002917 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002918 // Current can't be linked against by anything else.
2919 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002920 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002921 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002922 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002923 if err != nil {
2924 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002925 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002926 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002927 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002928 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002929 if err != nil {
2930 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002931 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002932 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002933 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002934
Inseob Kim01a28722018-04-11 09:48:45 +09002935 if toApi > fromApi {
2936 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002937 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002938 }
2939 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002940 }
Dan Albert202fe492017-12-15 13:56:59 -08002941
2942 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002943 fromStl := from.SelectedStl()
2944 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002945 if fromStl == "" || toStl == "" {
2946 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002947 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002948 // We can be permissive with the system "STL" since it is only the C++
2949 // ABI layer, but in the future we should make sure that everyone is
2950 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002951 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002952 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002953 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2954 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002955 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002956}
2957
Jooyung Han479ca172020-10-19 18:51:07 +09002958func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2959 if c, ok := ctx.Module().(*Module); ok {
2960 ctx.VisitDirectDeps(func(dep android.Module) {
2961 depTag := ctx.OtherModuleDependencyTag(dep)
2962 ccDep, ok := dep.(LinkableInterface)
2963 if ok {
2964 checkLinkType(ctx, c, ccDep, depTag)
2965 }
2966 })
2967 }
2968}
2969
Jiyong Park5fb8c102018-04-09 12:03:06 +09002970// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002971// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2972// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002973// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002974func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2975 check := func(child, parent android.Module) bool {
2976 to, ok := child.(*Module)
2977 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002978 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002979 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002980
Jooyung Hana70f0672019-01-18 15:20:43 +09002981 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2982 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002983 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002984
Jiyong Park0474e1f2021-01-14 14:26:06 +09002985 // These dependencies are not excercised at runtime. Tracking these will give us
2986 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002987 depTag := ctx.OtherModuleDependencyTag(child)
2988 if IsHeaderDepTag(depTag) {
2989 return false
2990 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002991 if depTag == staticVariantTag {
2992 return false
2993 }
2994 if depTag == stubImplDepTag {
2995 return false
2996 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002997
Justin Yun63e9ec72020-10-29 16:49:43 +09002998 // Even if target lib has no vendor variant, keep checking dependency
2999 // graph in case it depends on vendor_available or product_available
3000 // but not double_loadable transtively.
3001 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09003002 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09003003 }
Jooyung Hana70f0672019-01-18 15:20:43 +09003004
Jiyong Park0474e1f2021-01-14 14:26:06 +09003005 // The happy path. Keep tracking dependencies until we hit a non double-loadable
3006 // one.
3007 if Bool(to.VendorProperties.Double_loadable) {
3008 return true
3009 }
3010
Ivan Lozanod7586b62021-04-01 09:49:36 -04003011 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09003012 return false
3013 }
3014
Jooyung Hana70f0672019-01-18 15:20:43 +09003015 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
3016 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09003017 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09003018 return false
3019 }
3020 if module, ok := ctx.Module().(*Module); ok {
3021 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09003022 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09003023 ctx.WalkDeps(check)
3024 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09003025 }
3026 }
3027}
3028
Yu Liue4312402023-01-18 09:15:31 -08003029func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
3030 // For the dependency from platform to apex, use the latest stubs
3031 apexSdkVersion := android.FutureApiLevel
3032 if !apexInfo.IsForPlatform() {
3033 apexSdkVersion = apexInfo.MinSdkVersion
3034 }
3035
3036 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
3037 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
3038 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
3039 // (b/144430859)
3040 apexSdkVersion = android.FutureApiLevel
3041 }
3042
3043 return apexSdkVersion
3044}
3045
Colin Crossc99deeb2016-04-11 15:06:20 -07003046// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07003047func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08003048 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08003049
Colin Cross0de8a1e2020-09-18 14:15:30 -07003050 var directStaticDeps []StaticLibraryInfo
3051 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07003052
Colin Cross0de8a1e2020-09-18 14:15:30 -07003053 reexportExporter := func(exporter FlagExporterInfo) {
3054 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
3055 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
3056 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
3057 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
3058 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09003059 }
3060
Colin Cross56a83212020-09-15 18:30:11 -07003061 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Yu Liue4312402023-01-18 09:15:31 -08003062 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09003063
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003064 skipModuleList := map[string]bool{}
3065
3066 var apiImportInfo multitree.ApiImportInfo
3067 hasApiImportInfo := false
3068
3069 ctx.VisitDirectDeps(func(dep android.Module) {
3070 if dep.Name() == "api_imports" {
3071 apiImportInfo = ctx.OtherModuleProvider(dep, multitree.ApiImportsProvider).(multitree.ApiImportInfo)
3072 hasApiImportInfo = true
3073 }
3074 })
3075
3076 if hasApiImportInfo {
3077 targetStubModuleList := map[string]string{}
3078 targetOrigModuleList := map[string]string{}
3079
3080 // Search for dependency which both original module and API imported library with APEX stub exists
3081 ctx.VisitDirectDeps(func(dep android.Module) {
3082 depName := ctx.OtherModuleName(dep)
3083 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
3084 targetStubModuleList[apiLibrary] = depName
3085 }
3086 })
3087 ctx.VisitDirectDeps(func(dep android.Module) {
3088 depName := ctx.OtherModuleName(dep)
3089 if origLibrary, ok := targetStubModuleList[depName]; ok {
3090 targetOrigModuleList[origLibrary] = depName
3091 }
3092 })
3093
3094 // Decide which library should be used between original and API imported library
3095 ctx.VisitDirectDeps(func(dep android.Module) {
3096 depName := ctx.OtherModuleName(dep)
3097 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00003098 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003099 skipModuleList[depName] = true
3100 } else {
3101 skipModuleList[apiLibrary] = true
3102 }
3103 }
3104 })
3105 }
3106
Colin Crossd11fcda2017-10-23 17:59:01 -07003107 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003108 depName := ctx.OtherModuleName(dep)
3109 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07003110
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003111 if _, ok := skipModuleList[depName]; ok {
3112 // skip this module because original module or API imported module matching with this should be used instead.
3113 return
3114 }
3115
Dan Willemsen47450072021-10-19 20:24:49 -07003116 if depTag == android.DarwinUniversalVariantTag {
3117 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3118 return
3119 }
3120
Vinh Tran367d89d2023-04-28 11:21:25 -04003121 if depTag == aidlLibraryTag {
3122 if ctx.OtherModuleHasProvider(dep, aidl_library.AidlLibraryProvider) {
3123 depPaths.AidlLibraryInfos = append(
3124 depPaths.AidlLibraryInfos,
3125 ctx.OtherModuleProvider(
3126 dep,
3127 aidl_library.AidlLibraryProvider).(aidl_library.AidlLibraryInfo),
3128 )
3129 }
3130 }
3131
Ivan Lozano52767be2019-10-18 14:49:46 -07003132 ccDep, ok := dep.(LinkableInterface)
3133 if !ok {
3134
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003135 // handling for a few module types that aren't cc Module but that are also supported
3136 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003137 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003138 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003139 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3140 genRule.GeneratedSourceFiles()...)
3141 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003142 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003143 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003144 // Support exported headers from a generated_sources dependency
3145 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003146 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003147 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003148 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003149 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003150 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003151 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003152 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003153 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003154 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3155 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003156 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003157 // 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 +09003158 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003159
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003160 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003161 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003162 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003163 }
Colin Crosscef792e2021-06-11 18:01:26 -07003164 case CrtBeginDepTag:
3165 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3166 case CrtEndDepTag:
3167 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003168 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003169 return
3170 }
3171
Colin Crossfe17f6f2019-03-28 19:30:56 -07003172 if depTag == android.ProtoPluginDepTag {
3173 return
3174 }
3175
Colin Crossd11fcda2017-10-23 17:59:01 -07003176 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003177 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3178 return
3179 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003180 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003181 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3182 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003183 return
3184 }
3185
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003186 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003187 // Skip reused objects for stub libraries, they use their own stub object file instead.
3188 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3189 // version mutator, so the stubs variant is created from the shared variant that
3190 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003191 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07003192 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3193 objs := staticAnalogue.ReuseObjects
3194 depPaths.Objs = depPaths.Objs.Append(objs)
3195 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3196 reexportExporter(depExporterInfo)
3197 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003198 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003199 }
3200
Colin Cross6e511a92020-07-27 21:26:48 -07003201 linkFile := ccDep.OutputFile()
3202
3203 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3204 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003205 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003206 return
3207 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003208
Jiyong Parke3867542020-12-03 17:28:25 +09003209 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3210 return
3211 }
3212
Colin Cross0de8a1e2020-09-18 14:15:30 -07003213 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07003214
Colin Cross6e511a92020-07-27 21:26:48 -07003215 var ptr *android.Paths
3216 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003217
Colin Cross6e511a92020-07-27 21:26:48 -07003218 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003219
Colin Cross6e511a92020-07-27 21:26:48 -07003220 switch {
3221 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08003222 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
3223 if !ctx.Config().AllowMissingDependencies() {
3224 ctx.ModuleErrorf("module %q is not a header library", depName)
3225 } else {
3226 ctx.AddMissingDependencies([]string{depName})
3227 }
3228 return
3229 }
Colin Cross6e511a92020-07-27 21:26:48 -07003230 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003231 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
3232 if !ctx.Config().AllowMissingDependencies() {
3233 ctx.ModuleErrorf("module %q is not a shared library", depName)
3234 } else {
3235 ctx.AddMissingDependencies([]string{depName})
3236 }
3237 return
3238 }
Jiyong Parke3867542020-12-03 17:28:25 +09003239
Jiyong Park7d55b612021-06-11 17:22:09 +09003240 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3241 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003242
Jiyong Park1ad8e162020-12-01 23:40:09 +09003243 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3244 // linkFile, depFile, and ptr.
3245 if c.IsStubs() {
3246 break
3247 }
3248
Colin Cross0de8a1e2020-09-18 14:15:30 -07003249 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3250 depFile = sharedLibraryInfo.TableOfContents
3251
Colin Cross6e511a92020-07-27 21:26:48 -07003252 ptr = &depPaths.SharedLibs
3253 switch libDepTag.Order {
3254 case earlyLibraryDependency:
3255 ptr = &depPaths.EarlySharedLibs
3256 depPtr = &depPaths.EarlySharedLibsDeps
3257 case normalLibraryDependency:
3258 ptr = &depPaths.SharedLibs
3259 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003260 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003261 case lateLibraryDependency:
3262 ptr = &depPaths.LateSharedLibs
3263 depPtr = &depPaths.LateSharedLibsDeps
3264 default:
3265 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003266 }
Colin Cross6e511a92020-07-27 21:26:48 -07003267 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003268 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
3269 if !ctx.Config().AllowMissingDependencies() {
3270 ctx.ModuleErrorf("module %q is not a static library", depName)
3271 } else {
3272 ctx.AddMissingDependencies([]string{depName})
3273 }
3274 return
3275 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003276
3277 // Stubs lib doesn't link to the static lib dependencies. Don't set
3278 // linkFile, depFile, and ptr.
3279 if c.IsStubs() {
3280 break
3281 }
3282
Colin Cross0de8a1e2020-09-18 14:15:30 -07003283 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3284 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003285 if libDepTag.wholeStatic {
3286 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003287 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3288 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003289 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003290 // This case normally catches prebuilt static
3291 // libraries, but it can also occur when
3292 // AllowMissingDependencies is on and the
3293 // dependencies has no sources of its own
3294 // but has a whole_static_libs dependency
3295 // on a missing library. We want to depend
3296 // on the .a file so that there is something
3297 // in the dependency tree that contains the
3298 // error rule for the missing transitive
3299 // dependency.
3300 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003301 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003302 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3303 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003304 } else {
3305 switch libDepTag.Order {
3306 case earlyLibraryDependency:
3307 panic(fmt.Errorf("early static libs not suppported"))
3308 case normalLibraryDependency:
3309 // static dependencies will be handled separately so they can be ordered
3310 // using transitive dependencies.
3311 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003312 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003313 case lateLibraryDependency:
3314 ptr = &depPaths.LateStaticLibs
3315 default:
3316 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003317 }
3318 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003319 if libDepTag.unexportedSymbols {
3320 depPaths.LdFlags = append(depPaths.LdFlags,
3321 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3322 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003323 }
3324
Colin Cross6e511a92020-07-27 21:26:48 -07003325 if libDepTag.static() && !libDepTag.wholeStatic {
3326 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3327 ctx.ModuleErrorf("module %q not a static library", depName)
3328 return
3329 }
Logan Chien43d34c32017-12-20 01:17:32 +08003330
Colin Cross6e511a92020-07-27 21:26:48 -07003331 // When combining coverage files for shared libraries and executables, coverage files
3332 // in static libraries act as if they were whole static libraries. The same goes for
3333 // source based Abi dump files.
3334 if c, ok := ccDep.(*Module); ok {
3335 staticLib := c.linker.(libraryInterface)
3336 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3337 staticLib.objs().coverageFiles...)
3338 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3339 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003340 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003341 // Handle non-CC modules here
3342 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003343 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003344 }
3345 }
3346
Colin Cross6e511a92020-07-27 21:26:48 -07003347 if ptr != nil {
3348 if !linkFile.Valid() {
3349 if !ctx.Config().AllowMissingDependencies() {
3350 ctx.ModuleErrorf("module %q missing output file", depName)
3351 } else {
3352 ctx.AddMissingDependencies([]string{depName})
3353 }
3354 return
3355 }
3356 *ptr = append(*ptr, linkFile.Path())
3357 }
3358
3359 if depPtr != nil {
3360 dep := depFile
3361 if !dep.Valid() {
3362 dep = linkFile
3363 }
3364 *depPtr = append(*depPtr, dep.Path())
3365 }
3366
Colin Cross0de8a1e2020-09-18 14:15:30 -07003367 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3368 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3369 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3370 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3371
3372 if libDepTag.reexportFlags {
3373 reexportExporter(depExporterInfo)
3374 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3375 // Re-exported shared library headers must be included as well since they can help us with type information
3376 // about template instantiations (instantiated from their headers).
3377 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3378 // scripts.
3379 c.sabi.Properties.ReexportedIncludes = append(
3380 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3381 }
3382
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003383 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003384 switch {
3385 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003386 c.Properties.AndroidMkHeaderLibs = append(
3387 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003388 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003389 if lib := moduleLibraryInterface(dep); lib != nil {
3390 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003391 // Add the dependency to the APEX(es) providing the library so that
3392 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003393 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003394 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003395 c.Properties.ApexesProvidingSharedLibs = append(
3396 c.Properties.ApexesProvidingSharedLibs, an)
3397 }
3398 }
3399 }
3400
3401 // Note: the order of libs in this list is not important because
3402 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003403 c.Properties.AndroidMkSharedLibs = append(
3404 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003405 // Record BaseLibName for snapshots.
3406 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003407 case libDepTag.static():
3408 if libDepTag.wholeStatic {
3409 c.Properties.AndroidMkWholeStaticLibs = append(
3410 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3411 } else {
3412 c.Properties.AndroidMkStaticLibs = append(
3413 c.Properties.AndroidMkStaticLibs, makeLibName)
3414 }
Justin Yun5e035862021-06-29 20:50:37 +09003415 // Record BaseLibName for snapshots.
3416 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003417 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003418 } else if !c.IsStubs() {
3419 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3420
Colin Cross6e511a92020-07-27 21:26:48 -07003421 switch depTag {
3422 case runtimeDepTag:
3423 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003424 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003425 // Record BaseLibName for snapshots.
3426 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003427 case objDepTag:
3428 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3429 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003430 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003431 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003432 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003433 case dynamicLinkerDepTag:
3434 depPaths.DynamicLinker = linkFile
3435 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003436 }
Colin Crossca860ac2016-01-04 14:34:37 -08003437 })
3438
Jeff Gaston294356f2017-09-27 17:05:30 -07003439 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003440 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3441 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3442 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003443
Colin Crossdd84e052017-05-17 13:44:16 -07003444 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003445 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003446 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3447 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003448 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003449 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3450 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003451 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003452 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003453 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003454
3455 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003456 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003457 }
Colin Crossdd84e052017-05-17 13:44:16 -07003458
Colin Crossca860ac2016-01-04 14:34:37 -08003459 return depPaths
3460}
3461
Spandan Das604f3762023-03-16 22:51:40 +00003462func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003463 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003464 thisModule, ok := ctx.Module().(android.ApexModule)
3465 if !ok {
3466 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3467 }
3468
3469 useVndk := false
3470 bootstrap := false
3471 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3472 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3473 } else {
3474 useVndk = linkable.UseVndk()
3475 bootstrap = linkable.Bootstrap()
3476 }
3477
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003478 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3479
3480 useStubs := false
3481
3482 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3483 if !apexInfo.IsForPlatform() {
3484 // For platform libraries, use current version of LLNDK
3485 // If this is for use_vendor apex we will apply the same rules
3486 // of apex sdk enforcement below to choose right version.
3487 useStubs = true
3488 }
3489 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3490 // If not building for APEX or the containing APEX allows the use of
3491 // platform APIs, use stubs only when it is from an APEX (and not from
3492 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3493 // bootstrap modules, always link to non-stub variant
3494 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3495
3496 isApexImportedApiLibrary := false
3497
3498 if cc, ok := dep.(*Module); ok {
3499 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3500 if apiLibrary.hasApexStubs() {
3501 isApexImportedApiLibrary = true
3502 }
3503 }
3504 }
3505
3506 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3507
3508 if useStubs {
3509 // Another exception: if this module is a test for an APEX, then
3510 // it is linked with the non-stub variant of a module in the APEX
3511 // as if this is part of the APEX.
3512 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3513 for _, apexContents := range testFor.ApexContents {
3514 if apexContents.DirectlyInApex(depName) {
3515 useStubs = false
3516 break
3517 }
3518 }
3519 }
3520 if useStubs {
3521 // Yet another exception: If this module and the dependency are
3522 // available to the same APEXes then skip stubs between their
3523 // platform variants. This complements the test_for case above,
3524 // which avoids the stubs on a direct APEX library dependency, by
3525 // avoiding stubs for indirect test dependencies as well.
3526 //
3527 // TODO(b/183882457): This doesn't work if the two libraries have
3528 // only partially overlapping apex_available. For that test_for
3529 // modules would need to be split into APEX variants and resolved
3530 // separately for each APEX they have access to.
3531 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3532 useStubs = false
3533 }
3534 }
3535 } else {
3536 // If building for APEX, use stubs when the parent is in any APEX that
3537 // the child is not in.
3538 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3539 }
3540
3541 return useStubs
3542}
3543
3544// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3545// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3546// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3547// has different level of updatability. For example, if a library foo in an APEX depends on a
3548// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3549// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3550// same APEX as foo, the non-stub variant of bar is used.
3551func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3552 depTag := ctx.OtherModuleDependencyTag(dep)
3553 libDepTag, ok := depTag.(libraryDependencyTag)
3554 if !ok || !libDepTag.shared() {
3555 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3556 }
3557
Jiyong Park7d55b612021-06-11 17:22:09 +09003558 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3559 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3560 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Jiyong Park7d55b612021-06-11 17:22:09 +09003561
3562 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003563 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003564 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003565 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3566 toUse := stubs[len(stubs)-1]
3567 sharedLibraryInfo = toUse.SharedLibraryInfo
3568 depExporterInfo = toUse.FlagExporterInfo
3569 }
3570 }
3571 return sharedLibraryInfo, depExporterInfo
3572}
3573
Colin Cross0de8a1e2020-09-18 14:15:30 -07003574// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3575// to match the topological order of the dependency tree, including any static analogues of
3576// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3577// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003578func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3579 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003580 var staticPaths android.Paths
3581 for _, staticDep := range staticDeps {
3582 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3583 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3584 }
3585 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003586 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3587 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003588 }
3589 }
3590 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3591
3592 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3593
3594 // reorder the dependencies based on transitive dependencies
3595 staticPaths = android.FirstUniquePaths(staticPaths)
3596 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3597
3598 if len(orderedStaticPaths) != len(staticPaths) {
3599 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3600 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3601 }
3602
3603 return orderedStaticPaths, transitiveStaticLibs
3604}
3605
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003606// BaseLibName trims known prefixes and suffixes
3607func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003608 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3609 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003610 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003611 return libName
3612}
3613
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003614func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003615 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003616 ccDepModule, _ := ccDep.(*Module)
3617 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003618 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003619
Justin Yuncbca3732021-02-03 19:24:13 +09003620 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003621 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003622 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003623 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003624
Ivan Lozanod1dec542021-05-26 15:33:11 -04003625 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003626 }
3627 }
3628
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003629 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3630 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003631 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3632 // core module instead.
3633 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003634 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003635 // The vendor and product modules in Make will have been renamed to not conflict with the
3636 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003637 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003638 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003639 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003640 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003641 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003642 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003643 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003644 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003645 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003646 } else {
3647 return libName
3648 }
3649}
3650
Colin Crossca860ac2016-01-04 14:34:37 -08003651func (c *Module) InstallInData() bool {
3652 if c.installer == nil {
3653 return false
3654 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003655 return c.installer.inData()
3656}
3657
3658func (c *Module) InstallInSanitizerDir() bool {
3659 if c.installer == nil {
3660 return false
3661 }
3662 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003663 return true
3664 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003665 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003666}
3667
Yifan Hong1b3348d2020-01-21 15:53:22 -08003668func (c *Module) InstallInRamdisk() bool {
3669 return c.InRamdisk()
3670}
3671
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003672func (c *Module) InstallInVendorRamdisk() bool {
3673 return c.InVendorRamdisk()
3674}
3675
Jiyong Parkf9332f12018-02-01 00:54:12 +09003676func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003677 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003678}
3679
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003680func (c *Module) MakeUninstallable() {
3681 if c.installer == nil {
3682 c.ModuleBase.MakeUninstallable()
3683 return
3684 }
3685 c.installer.makeUninstallable(c)
3686}
3687
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003688func (c *Module) HostToolPath() android.OptionalPath {
3689 if c.installer == nil {
3690 return android.OptionalPath{}
3691 }
3692 return c.installer.hostToolPath()
3693}
3694
Nan Zhangd4e641b2017-07-12 12:55:28 -07003695func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3696 return c.outputFile
3697}
3698
Colin Cross41955e82019-05-29 14:40:35 -07003699func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3700 switch tag {
3701 case "":
3702 if c.outputFile.Valid() {
3703 return android.Paths{c.outputFile.Path()}, nil
3704 }
3705 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003706 case "unstripped":
3707 if c.linker != nil {
3708 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3709 }
3710 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003711 default:
3712 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003713 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003714}
3715
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003716func (c *Module) static() bool {
3717 if static, ok := c.linker.(interface {
3718 static() bool
3719 }); ok {
3720 return static.static()
3721 }
3722 return false
3723}
3724
Jiyong Park379de2f2018-12-19 02:47:14 +09003725func (c *Module) staticBinary() bool {
3726 if static, ok := c.linker.(interface {
3727 staticBinary() bool
3728 }); ok {
3729 return static.staticBinary()
3730 }
3731 return false
3732}
3733
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003734func (c *Module) testBinary() bool {
3735 if test, ok := c.linker.(interface {
3736 testBinary() bool
3737 }); ok {
3738 return test.testBinary()
3739 }
3740 return false
3741}
3742
Jingwen Chen537242c2022-08-24 11:53:27 +00003743func (c *Module) testLibrary() bool {
3744 if test, ok := c.linker.(interface {
3745 testLibrary() bool
3746 }); ok {
3747 return test.testLibrary()
3748 }
3749 return false
3750}
3751
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003752func (c *Module) benchmarkBinary() bool {
3753 if b, ok := c.linker.(interface {
3754 benchmarkBinary() bool
3755 }); ok {
3756 return b.benchmarkBinary()
3757 }
3758 return false
3759}
3760
3761func (c *Module) fuzzBinary() bool {
3762 if f, ok := c.linker.(interface {
3763 fuzzBinary() bool
3764 }); ok {
3765 return f.fuzzBinary()
3766 }
3767 return false
3768}
3769
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003770// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3771func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003772 if h, ok := c.linker.(interface {
3773 header() bool
3774 }); ok {
3775 return h.header()
3776 }
3777 return false
3778}
3779
Ivan Lozanod7586b62021-04-01 09:49:36 -04003780func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003781 if b, ok := c.linker.(interface {
3782 binary() bool
3783 }); ok {
3784 return b.binary()
3785 }
3786 return false
3787}
3788
Justin Yun5e035862021-06-29 20:50:37 +09003789func (c *Module) StaticExecutable() bool {
3790 if b, ok := c.linker.(*binaryDecorator); ok {
3791 return b.static()
3792 }
3793 return false
3794}
3795
Ivan Lozanod7586b62021-04-01 09:49:36 -04003796func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003797 if o, ok := c.linker.(interface {
3798 object() bool
3799 }); ok {
3800 return o.object()
3801 }
3802 return false
3803}
3804
Ivan Lozanof9e21722020-12-02 09:00:51 -05003805func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003806 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003807 if c.IsLlndk() {
3808 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003809 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003810 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003811 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003812 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003813 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003814 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003815 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003816 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003817 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003818 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003819 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003820 return "native:product"
3821 }
Jooyung Han38002912019-05-16 04:01:54 +09003822 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003823 } else if c.InRamdisk() {
3824 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003825 } else if c.InVendorRamdisk() {
3826 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003827 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003828 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003829 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003830 return "native:ndk:none:none"
3831 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3832 //family, link := getNdkStlFamilyAndLinkType(c)
3833 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003834 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003835 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003836 } else {
3837 return "native:platform"
3838 }
3839}
3840
Jiyong Park9d452992018-10-03 00:38:19 +09003841// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003842// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003843func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003844 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003845 // Stub libs and prebuilt libs in a versioned SDK are not
3846 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003847 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003848 } else if _, ok := c.linker.(testPerSrc); ok {
3849 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003850 }
3851 return false
3852}
3853
Jiyong Parka90ca002019-10-07 15:47:24 +09003854func (c *Module) AvailableFor(what string) bool {
3855 if linker, ok := c.linker.(interface {
3856 availableFor(string) bool
3857 }); ok {
3858 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3859 } else {
3860 return c.ApexModuleBase.AvailableFor(what)
3861 }
3862}
3863
Jiyong Park62304bb2020-04-13 16:19:48 +09003864func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003865 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003866}
3867
Paul Duffin0cb37b92020-03-04 14:52:46 +00003868func (c *Module) EverInstallable() bool {
3869 return c.installer != nil &&
3870 // Check to see whether the module is actually ever installable.
3871 c.installer.everInstallable()
3872}
3873
Ivan Lozanod7586b62021-04-01 09:49:36 -04003874func (c *Module) PreventInstall() bool {
3875 return c.Properties.PreventInstall
3876}
3877
3878func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003879 if c.library != nil {
3880 if i := c.library.installable(); i != nil {
3881 return i
3882 }
3883 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003884 return c.Properties.Installable
3885}
3886
3887func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003888 ret := c.EverInstallable() &&
3889 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003890 proptools.BoolDefault(c.Installable(), true) &&
3891 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003892
3893 // The platform variant doesn't need further condition. Apex variants however might not
3894 // be installable because it will likely to be included in the APEX and won't appear
3895 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003896 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003897 return ret
3898 }
3899
3900 // Special case for modules that are configured to be installed to /data, which includes
3901 // test modules. For these modules, both APEX and non-APEX variants are considered as
3902 // installable. This is because even the APEX variants won't be included in the APEX, but
3903 // will anyway be installed to /data/*.
3904 // See b/146995717
3905 if c.InstallInData() {
3906 return ret
3907 }
3908
3909 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003910}
3911
Logan Chien41eabe62019-04-10 13:33:58 +08003912func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3913 if c.linker != nil {
3914 if library, ok := c.linker.(*libraryDecorator); ok {
3915 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3916 }
3917 }
3918}
3919
Jiyong Park45bf82e2020-12-15 22:29:02 +09003920var _ android.ApexModule = (*Module)(nil)
3921
3922// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003923func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003924 depTag := ctx.OtherModuleDependencyTag(dep)
3925 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3926
3927 if cc, ok := dep.(*Module); ok {
3928 if cc.HasStubsVariants() {
3929 if isLibDepTag && libDepTag.shared() {
3930 // dynamic dep to a stubs lib crosses APEX boundary
3931 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003932 }
Colin Cross6e511a92020-07-27 21:26:48 -07003933 if IsRuntimeDepTag(depTag) {
3934 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003935 return false
3936 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003937 }
Zhijun Heec285872021-04-24 10:47:08 -07003938 if cc.IsLlndk() {
3939 return false
3940 }
Colin Crossaac32222020-07-29 12:51:56 -07003941 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003942 // shared_lib dependency from a static lib is considered as crossing
3943 // the APEX boundary because the dependency doesn't actually is
3944 // linked; the dependency is used only during the compilation phase.
3945 return false
3946 }
Jiyong Parke3867542020-12-03 17:28:25 +09003947
3948 if isLibDepTag && libDepTag.excludeInApex {
3949 return false
3950 }
Colin Cross6e511a92020-07-27 21:26:48 -07003951 }
Colin Crossc1b36442021-05-06 13:42:48 -07003952 if depTag == stubImplDepTag {
3953 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003954 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003955 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003956 if depTag == staticVariantTag {
3957 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3958 // actually mean that the static lib (and its dependencies) are copied into the
3959 // APEX.
3960 return false
3961 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003962 return true
3963}
3964
Jiyong Park45bf82e2020-12-15 22:29:02 +09003965// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003966func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3967 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003968 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3969 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3970 return nil
3971 }
Jooyung Han749dc692020-04-15 11:03:39 +09003972 // We don't check for prebuilt modules
3973 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3974 return nil
3975 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003976
Jooyung Han749dc692020-04-15 11:03:39 +09003977 minSdkVersion := c.MinSdkVersion()
3978 if minSdkVersion == "apex_inherit" {
3979 return nil
3980 }
3981 if minSdkVersion == "" {
3982 // JNI libs within APK-in-APEX fall into here
3983 // Those are okay to set sdk_version instead
3984 // We don't have to check if this is a SDK variant because
3985 // non-SDK variant resets sdk_version, which works too.
3986 minSdkVersion = c.SdkVersion()
3987 }
Dan Albertc8060532020-07-22 22:32:17 -07003988 if minSdkVersion == "" {
3989 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3990 }
3991 // Not using nativeApiLevelFromUser because the context here is not
3992 // necessarily a native context.
3993 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003994 if err != nil {
3995 return err
3996 }
Dan Albertc8060532020-07-22 22:32:17 -07003997
Colin Cross8ca61c12022-10-06 21:00:14 -07003998 // A dependency only needs to support a min_sdk_version at least
3999 // as high as the api level that the architecture was introduced in.
4000 // This allows introducing new architectures in the platform that
4001 // need to be included in apexes that normally require an older
4002 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08004003 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07004004 if sdkVersion.LessThan(minApiForArch) {
4005 sdkVersion = minApiForArch
4006 }
4007
Dan Albertc8060532020-07-22 22:32:17 -07004008 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09004009 return fmt.Errorf("newer SDK(%v)", ver)
4010 }
4011 return nil
4012}
4013
Paul Duffinb5769c12021-05-12 16:16:51 +01004014// Implements android.ApexModule
4015func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
4016 // stub libraries and native bridge libraries are always available to platform
4017 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
4018}
4019
Jooyung Han91f92032022-02-04 12:36:33 +09004020// Overrides android.ApexModuleBase.UniqueApexVariations
4021func (c *Module) UniqueApexVariations() bool {
4022 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
4023 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
4024 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09004025 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09004026 return c.UseVndk() && c.IsVndk()
4027}
4028
Inseob Kima1888ce2022-10-04 14:42:02 +09004029func (c *Module) overriddenModules() []string {
4030 if o, ok := c.linker.(overridable); ok {
4031 return o.overriddenModules()
4032 }
4033 return nil
4034}
4035
Rob Seymour925aa092021-08-10 20:42:03 +00004036var _ snapshot.RelativeInstallPath = (*Module)(nil)
4037
Liz Kammer35ca77e2021-12-22 15:31:40 -05004038type moduleType int
4039
4040const (
4041 unknownType moduleType = iota
4042 binary
4043 object
4044 fullLibrary
4045 staticLibrary
4046 sharedLibrary
4047 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00004048 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00004049 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05004050)
4051
4052func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00004053 if c.testBinary() {
4054 // testBinary is also a binary, so this comes before the c.Binary()
4055 // conditional. A testBinary has additional implicit dependencies and
4056 // other test-only semantics.
4057 return testBin
4058 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004059 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004060 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004061 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00004062 } else if c.testLibrary() {
4063 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
4064 // will let them add implicit compile deps on gtest, for example.
4065 //
Liz Kammerefc51d92023-04-21 15:11:25 -04004066 // For now, treat them as regular libraries.
4067 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004068 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05004069 static := false
4070 shared := false
4071 if library, ok := c.linker.(*libraryDecorator); ok {
4072 static = library.MutatedProperties.BuildStatic
4073 shared = library.MutatedProperties.BuildShared
4074 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
4075 static = library.MutatedProperties.BuildStatic
4076 shared = library.MutatedProperties.BuildShared
4077 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004078 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004079 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004080 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004081 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004082 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004083 return staticLibrary
4084 }
4085 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00004086 } else if c.isNDKStubLibrary() {
4087 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05004088 }
4089 return unknownType
4090}
4091
4092// ConvertWithBp2build converts Module to Bazel for bp2build.
4093func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
4094 prebuilt := c.IsPrebuilt()
4095 switch c.typ() {
4096 case binary:
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxb12ff592022-09-01 15:04:04 +00004097 if prebuilt {
4098 prebuiltBinaryBp2Build(ctx, c)
4099 } else {
Jingwen Chen537242c2022-08-24 11:53:27 +00004100 binaryBp2build(ctx, c)
4101 }
4102 case testBin:
4103 if !prebuilt {
4104 testBinaryBp2build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004105 }
4106 case object:
Colin Crossc5075e92022-12-05 16:46:39 -08004107 if prebuilt {
4108 prebuiltObjectBp2Build(ctx, c)
4109 } else {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004110 objectBp2Build(ctx, c)
4111 }
4112 case fullLibrary:
4113 if !prebuilt {
4114 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00004115 } else {
4116 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004117 }
4118 case headerLibrary:
4119 libraryHeadersBp2Build(ctx, c)
4120 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05004121 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00004122 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004123 } else {
4124 sharedOrStaticLibraryBp2Build(ctx, c, true)
4125 }
4126 case sharedLibrary:
4127 if prebuilt {
4128 prebuiltLibrarySharedBp2Build(ctx, c)
4129 } else {
4130 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004131 }
Chris Parsons39a16972023-06-08 14:28:51 +00004132 default:
4133 ctx.MarkBp2buildUnconvertible(bp2build_metrics_proto.UnconvertedReasonType_TYPE_UNSUPPORTED, "")
Spandan Das8b4a5f32022-09-29 00:28:24 +00004134 }
4135}
4136
4137var _ android.ApiProvider = (*Module)(nil)
4138
4139func (c *Module) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
Spandan Das4238c652022-09-09 01:38:47 +00004140 if c.IsPrebuilt() {
4141 return
4142 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00004143 switch c.typ() {
Spandan Das4238c652022-09-09 01:38:47 +00004144 case fullLibrary:
4145 apiContributionBp2Build(ctx, c)
4146 case sharedLibrary:
4147 apiContributionBp2Build(ctx, c)
4148 case headerLibrary:
4149 // Aggressively generate api targets for all header modules
4150 // This is necessary since the header module does not know if it is a dep of API surface stub library
4151 apiLibraryHeadersBp2Build(ctx, c)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004152 }
4153}
4154
Colin Crosscfad1192015-11-02 16:43:11 -08004155// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004156type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004157 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004158 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004159 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08004160}
4161
Patrice Arrudac249c712019-03-19 17:00:29 -07004162// cc_defaults provides a set of properties that can be inherited by other cc
4163// modules. A module can use the properties from a cc_defaults using
4164// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4165// merged (when possible) by prepending the default module's values to the
4166// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004167func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004168 return DefaultsFactory()
4169}
4170
Colin Cross36242852017-06-23 15:06:31 -07004171func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004172 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004173
Colin Cross36242852017-06-23 15:06:31 -07004174 module.AddProperties(props...)
4175 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004176 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004177 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004178 &BaseCompilerProperties{},
4179 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004180 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004181 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004182 &StaticProperties{},
4183 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004184 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004185 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004186 &TestLinkerProperties{},
4187 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004188 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004189 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004190 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004191 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004192 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004193 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004194 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004195 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004196 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004197 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004198 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004199 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004200 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07004201 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004202 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004203 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4204 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004205 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004206 )
Colin Crosscfad1192015-11-02 16:43:11 -08004207
Jooyung Hancc372c52019-09-25 15:18:44 +09004208 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004209
4210 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004211}
4212
Jiyong Park2286afd2020-06-16 21:58:53 +09004213func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004214 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004215}
4216
Kiyoung Kim51279d32022-08-24 14:10:46 +09004217func (c *Module) isImportedApiLibrary() bool {
4218 _, ok := c.linker.(*apiLibraryDecorator)
4219 return ok
4220}
4221
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004222func kytheExtractAllFactory() android.Singleton {
4223 return &kytheExtractAllSingleton{}
4224}
4225
4226type kytheExtractAllSingleton struct {
4227}
4228
4229func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4230 var xrefTargets android.Paths
4231 ctx.VisitAllModules(func(module android.Module) {
4232 if ccModule, ok := module.(xref); ok {
4233 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4234 }
4235 })
4236 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4237 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004238 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004239 }
4240}
4241
Jihoon Kangf78a8902022-09-01 22:47:07 +00004242func (c *Module) Partition() string {
4243 if p, ok := c.installer.(interface {
4244 getPartition() string
4245 }); ok {
4246 return p.getPartition()
4247 }
4248 return ""
4249}
4250
Colin Cross06a931b2015-10-28 17:23:31 -07004251var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004252var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004253var BoolPtr = proptools.BoolPtr
4254var String = proptools.String
4255var StringPtr = proptools.StringPtr