blob: c13f7c90657d7fb37801b3fd2a2dbaa6f2bc66c4 [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"
Liz Kammer1cec9d12023-06-22 10:09:47 -040028
Colin Cross97ba0732015-03-23 17:50:24 -070029 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070030 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070031
Vinh Tran367d89d2023-04-28 11:21:25 -040032 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070033 "android/soong/android"
Sam Delmerico5fb794a2023-01-27 16:01:37 -050034 "android/soong/bazel/cquery"
Colin Crossb98c8b02016-07-29 13:44:28 -070035 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070036 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070037 "android/soong/genrule"
Kiyoung Kim487689e2022-07-26 09:48:22 +090038 "android/soong/multitree"
Rob Seymour925aa092021-08-10 20:42:03 +000039 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080040)
41
Colin Cross463a90e2015-06-17 14:20:06 -070042func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000043 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070044
Paul Duffin036e7002019-12-19 19:16:28 +000045 pctx.Import("android/soong/cc/config")
46}
47
48func RegisterCCBuildComponents(ctx android.RegistrationContext) {
49 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
50
51 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000052 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090053 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070054 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010055 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070056 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070057 ctx.BottomUp("begin", BeginMutator).Parallel()
Vinh Tran44cb78c2023-03-09 22:07:19 -050058 ctx.BottomUp("fdo_profile", fdoProfileMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070059 })
Colin Cross16b23492016-01-06 14:41:07 -080060
Paul Duffin036e7002019-12-19 19:16:28 +000061 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040062 for _, san := range Sanitizers {
63 san.registerMutators(ctx)
64 }
Dan Willemsen581341d2017-02-09 16:16:31 -080065
Colin Cross0b908332019-06-19 23:00:20 -070066 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090067 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080068
Cory Barkera1da26f2022-06-07 20:12:06 +000069 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000070
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080071 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070072
Yi Kongeb8efc92021-12-09 18:06:29 +080073 ctx.TopDown("afdo_deps", afdoDepsMutator)
74 ctx.BottomUp("afdo", afdoMutator).Parallel()
75
Stephen Craneba090d12017-05-09 15:44:35 -070076 ctx.TopDown("lto_deps", ltoDepsMutator)
77 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090078
Jooyung Han479ca172020-10-19 18:51:07 +090079 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090080 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070081 })
Colin Crossb98c8b02016-07-29 13:44:28 -070082
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080083 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
84 // sabi mutator needs to be run after apex mutator finishes.
85 ctx.TopDown("sabi_deps", sabiDepsMutator)
86 })
87
LaMont Jones0c10e4d2023-05-16 00:58:37 +000088 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070089}
90
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050091// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
92// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
93// edges to these modules.
94// This object is constructed in DepsMutator, by calling to various module delegates to set
95// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
96// dependencies.
97// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
98// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080099type Deps struct {
100 SharedLibs, LateSharedLibs []string
101 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800102 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800103 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700104
Colin Cross3e5e7782022-06-17 22:17:05 +0000105 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
106 // prevent automatically exporting symbols.
107 UnexportedStaticLibs []string
108
Chris Parsons79d66a52020-06-05 17:26:16 -0400109 // Used for data dependencies adjacent to tests
110 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700111 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400112
Yo Chiang219968c2020-09-22 18:45:04 +0800113 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
114 SystemSharedLibs []string
115
Vinh Tran367d89d2023-04-28 11:21:25 -0400116 // Used by DepMutator to pass aidl_library modules to aidl compiler
117 AidlLibs []string
118
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500119 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800120 StaticUnwinderIfLegacy bool
121
Colin Cross5950f382016-12-13 12:50:57 -0800122 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700123
Colin Cross81413472016-04-11 14:37:39 -0700124 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700125
Dan Willemsenb40aab62016-04-20 14:21:14 -0700126 GeneratedSources []string
127 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900128 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700129
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700130 ReexportGeneratedHeaders []string
131
Colin Crossc465efd2021-06-11 18:00:04 -0700132 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700133
134 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700135 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900136
137 // List of libs that need to be excluded for APEX variant
138 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700139}
140
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500141// PathDeps is a struct containing file paths to dependencies of a module.
142// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
143// It's used to construct flags for various build statements (such as for compiling and linking).
144// It is then passed to module decorator functions responsible for registering build statements
145// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800146type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700147 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900148 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700149 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900150 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700151 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700152 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700153
Colin Cross0de8a1e2020-09-18 14:15:30 -0700154 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossc85750b2022-04-21 12:50:51 -0700155 TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700156
Colin Cross26c34ed2016-09-30 17:10:16 -0700157 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100158 Objs Objects
159 // Paths to .o files in dependencies that provide them. Note that these lists
160 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800161 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700162 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700163
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100164 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
165 // the libs from all whole_static_lib dependencies.
166 WholeStaticLibsFromPrebuilts android.Paths
167
Colin Cross26c34ed2016-09-30 17:10:16 -0700168 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700169 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900170 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700171
Inseob Kimd110f872019-12-06 13:15:38 +0900172 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000173 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900174 IncludeDirs android.Paths
175 SystemIncludeDirs android.Paths
176 ReexportedDirs android.Paths
177 ReexportedSystemDirs android.Paths
178 ReexportedFlags []string
179 ReexportedGeneratedHeaders android.Paths
180 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700181
Colin Cross26c34ed2016-09-30 17:10:16 -0700182 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700183 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700184
Dan Willemsena0790e32018-10-12 00:24:23 -0700185 // Path to the dynamic linker binary
186 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700187
188 // For Darwin builds, the path to the second architecture's output that should
189 // be combined with this architectures's output into a FAT MachO file.
190 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400191
192 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
193 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700194}
195
Colin Cross4af21ed2019-11-04 09:37:55 -0800196// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
197// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
198// command line so they can be overridden by the local module flags).
199type LocalOrGlobalFlags struct {
200 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700201 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800202 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700203 CFlags []string // Flags that apply to C and C++ source files
204 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
205 ConlyFlags []string // Flags that apply to C source files
206 CppFlags []string // Flags that apply to C++ source files
207 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700208 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800209}
210
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500211// Flags contains various types of command line flags (and settings) for use in building build
212// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800213type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500214 // Local flags (which individual modules are responsible for). These may override global flags.
215 Local LocalOrGlobalFlags
216 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800217 Global LocalOrGlobalFlags
218
219 aidlFlags []string // Flags that apply to aidl source files
220 rsFlags []string // Flags that apply to renderscript source files
221 libFlags []string // Flags to add libraries early to the link order
222 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
223 TidyFlags []string // Flags that apply to clang-tidy
224 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700225
Colin Crossc3199482017-03-30 15:03:04 -0700226 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800227 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700228 SystemIncludeFlags []string
229
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800230 Toolchain config.Toolchain
231 Tidy bool // True if ninja .tidy rules should be generated.
232 NeedTidyFiles bool // True if module link should depend on .tidy files
233 GcovCoverage bool // True if coverage files should be generated.
234 SAbiDump bool // True if header abi dumps should be generated.
235 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800236
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500237 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800238 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500239 // The target-device system path to the dynamic linker.
240 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800241
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700242 CFlagsDeps android.Paths // Files depended on by compiler flags
243 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800244
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500245 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700246 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800247
Colin Cross19878da2019-03-28 14:45:07 -0700248 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700249 protoC bool // Whether to use C instead of C++
250 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700251
252 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200253 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700254}
255
Colin Crossca860ac2016-01-04 14:34:37 -0800256// Properties used to compile all C or C++ modules
257type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700258 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800259 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700260
Jiyong Parkb35a8192020-08-10 15:59:36 +0900261 // The API level that this module is built against. The APIs of this API level will be
262 // visible at build time, but use of any APIs newer than min_sdk_version will render the
263 // module unloadable on older devices. In the future it will be possible to weakly-link new
264 // APIs, making the behavior match Java: such modules will load on older devices, but
265 // calling new APIs on devices that do not support them will result in a crash.
266 //
267 // This property has the same behavior as sdk_version does for Java modules. For those
268 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
269 // does for Java code.
270 //
271 // In addition, setting this property causes two variants to be built, one for the platform
272 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800273 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700274
Jiyong Parkb35a8192020-08-10 15:59:36 +0900275 // Minimum OS API level supported by this C or C++ module. This property becomes the value
276 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
277 // this property is also used to ensure that the min_sdk_version of the containing module is
278 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
279 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
280 // min_sdk_version of the containing APEX. When the module
281 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900282 Min_sdk_version *string
283
Colin Crossc511bc52020-04-07 16:50:32 +0000284 // If true, always create an sdk variant and don't create a platform variant.
285 Sdk_variant_only *bool
286
Jiyong Parkde866cb2018-12-07 23:08:36 +0900287 AndroidMkSharedLibs []string `blueprint:"mutated"`
288 AndroidMkStaticLibs []string `blueprint:"mutated"`
289 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
290 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700291 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900292 HideFromMake bool `blueprint:"mutated"`
293 PreventInstall bool `blueprint:"mutated"`
294 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700295
Yo Chiang219968c2020-09-22 18:45:04 +0800296 // Set by DepsMutator.
297 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
298
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200299 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900300 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200301
302 // The VNDK version this module is built against. If empty, the module is not
303 // build against the VNDK.
304 VndkVersion string `blueprint:"mutated"`
305
306 // Suffix for the name of Android.mk entries generated by this module
307 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800308
309 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
310 // file
311 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900312
Yifan Hong39143a92020-10-26 12:43:12 -0700313 // Make this module available when building for ramdisk.
314 // On device without a dedicated recovery partition, the module is only
315 // available after switching root into
316 // /first_stage_ramdisk. To expose the module before switching root, install
317 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800318 Ramdisk_available *bool
319
Yifan Hong39143a92020-10-26 12:43:12 -0700320 // Make this module available when building for vendor ramdisk.
321 // On device without a dedicated recovery partition, the module is only
322 // available after switching root into
323 // /first_stage_ramdisk. To expose the module before switching root, install
324 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700325 Vendor_ramdisk_available *bool
326
Jiyong Parkf9332f12018-02-01 00:54:12 +0900327 // Make this module available when building for recovery
328 Recovery_available *bool
329
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200330 // Used by imageMutator, set by ImageMutatorBegin()
331 CoreVariantNeeded bool `blueprint:"mutated"`
332 RamdiskVariantNeeded bool `blueprint:"mutated"`
333 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
334 RecoveryVariantNeeded bool `blueprint:"mutated"`
335
336 // A list of variations for the "image" mutator of the form
337 //<image name> '.' <version char>, for example, 'vendor.S'
338 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900339
340 // Allows this module to use non-APEX version of libraries. Useful
341 // for building binaries that are started before APEXes are activated.
342 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900343
344 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
345 // see soong/cc/config/vndk.go
346 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900347
348 // Used by vendor snapshot to record dependencies from snapshot modules.
349 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900350 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900351 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000352
Colin Cross1bc94122021-10-28 13:25:54 -0700353 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000354
355 // Set by factories of module types that can only be referenced from variants compiled against
356 // the SDK.
357 AlwaysSdk bool `blueprint:"mutated"`
358
359 // Variant is an SDK variant created by sdkMutator
360 IsSdkVariant bool `blueprint:"mutated"`
361 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
362 // variant to have a ".sdk" suffix.
363 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700364
365 // Normally Soong uses the directory structure to decide which modules
366 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800367 // different snapshots (vendor, recovery, etc.), but this property
368 // allows a partner to exclude a module normally thought of as a
369 // framework module from the vendor snapshot.
370 Exclude_from_vendor_snapshot *bool
371
372 // Normally Soong uses the directory structure to decide which modules
373 // should be included (framework) or excluded (non-framework) from the
374 // different snapshots (vendor, recovery, etc.), but this property
375 // allows a partner to exclude a module normally thought of as a
376 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800377 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900378
379 // List of APEXes that this module has private access to for testing purpose. The module
380 // can depend on libraries that are not exported by the APEXes and use private symbols
381 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000382 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800383
384 Target struct {
385 Platform struct {
386 // List of modules required by the core variant.
387 Required []string `android:"arch_variant"`
388
389 // List of modules not required by the core variant.
390 Exclude_required []string `android:"arch_variant"`
391 } `android:"arch_variant"`
392
393 Recovery struct {
394 // List of modules required by the recovery variant.
395 Required []string `android:"arch_variant"`
396
397 // List of modules not required by the recovery variant.
398 Exclude_required []string `android:"arch_variant"`
399 } `android:"arch_variant"`
400 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700401}
402
403type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900404 // whether this module should be allowed to be directly depended by other
405 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900406 // If set to true, two variants will be built separately, one like
407 // normal, and the other limited to the set of libraries and headers
408 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700409 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900410 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700411 // so it shouldn't have any unversioned runtime dependencies, or
412 // make assumptions about the system that may not be true in the
413 // future.
414 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900415 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900416 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900417 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900418 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900419 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700420 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
421 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900422
Justin Yunebcf0c52021-01-08 18:00:19 +0900423 // This is the same as the "vendor_available" except that the install path
424 // of the vendor variant is /odm or /vendor/odm.
425 // By replacing "vendor_available: true" with "odm_available: true", the
426 // module will install its vendor variant to the /odm partition or /vendor/odm.
427 // As the modules with "odm_available: true" still create the vendor variants,
428 // they can link to the other vendor modules as the vendor_available modules do.
429 // Also, the vendor modules can link to odm_available modules.
430 //
431 // It may not be used for VNDK modules.
432 Odm_available *bool
433
Justin Yun63e9ec72020-10-29 16:49:43 +0900434 // whether this module should be allowed to be directly depended by other
435 // modules with `product_specific: true` or `product_available: true`.
436 // If set to true, an additional product variant will be built separately
437 // that is limited to the set of libraries and headers that are exposed to
438 // /product modules.
439 //
440 // The product variant may be used with a different (newer) /system,
441 // so it shouldn't have any unversioned runtime dependencies, or
442 // make assumptions about the system that may not be true in the
443 // future.
444 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900445 // If set to false, this module becomes inaccessible from /product modules.
446 //
447 // Different from the 'vendor_available' property, the modules with
448 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
449 // library without 'product_available' may not be depended on by any other
450 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900451 //
452 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
453 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
454 Product_available *bool
455
Jiyong Park5fb8c102018-04-09 12:03:06 +0900456 // whether this module is capable of being loaded with other instance
457 // (possibly an older version) of the same module in the same process.
458 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
459 // can be double loaded in a vendor process if the library is also a
460 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
461 // explicitly marked as `double_loadable: true` by the owner, or the dependency
462 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
463 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800464
465 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
466 IsLLNDK bool `blueprint:"mutated"`
467
Colin Cross78212242021-01-06 14:51:30 -0800468 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
469 // set and the module is not listed in VndkMustUseVendorVariantList.
470 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
471
472 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
473 IsVNDKCore bool `blueprint:"mutated"`
474
475 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
476 IsVNDKSP bool `blueprint:"mutated"`
477
478 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
479 // module sets the llndk.private property.
480 IsVNDKPrivate bool `blueprint:"mutated"`
481
482 // IsVNDKProduct is set if a VNDK module sets the product_available property.
483 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700484
485 // IsVendorPublicLibrary is set for the core and product variants of a library that has
486 // vendor_public_library stubs.
487 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800488}
489
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500490// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
491// to understanding details about the type of the current module.
492// For example, one might call these functions to determine whether the current module is a static
493// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800494type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800495 static() bool
496 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700497 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800498 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900499 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900500 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900501 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700502 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900503 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700504 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800505 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900506 minSdkVersion() string
507 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700508 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700509 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800510 IsLlndk() bool
511 IsLlndkPublic() bool
512 isImplementationForLLNDKPublic() bool
513 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900514 isVndk() bool
515 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500516 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700517 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900518 inProduct() bool
519 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800520 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700521 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900522 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700523 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700524 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800525 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800526 isAfdoCompile() bool
Yi Kong7e53c572018-02-14 18:16:12 +0800527 isPgoCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800528 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900529 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800530 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800531 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800532 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700533 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700534 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900535 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800536 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700537 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700538 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800539 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800540 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800541 getSharedFlags() *SharedFlags
542}
543
544type SharedFlags struct {
545 numSharedFlags int
546 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800547}
548
549type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700550 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800551 ModuleContextIntf
552}
553
554type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700555 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800556 ModuleContextIntf
557}
558
Colin Cross37047f12016-12-13 17:06:13 -0800559type DepsContext interface {
560 android.BottomUpMutatorContext
561 ModuleContextIntf
562}
563
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500564// feature represents additional (optional) steps to building cc-related modules, such as invocation
565// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800566type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800567 flags(ctx ModuleContext, flags Flags) Flags
568 props() []interface{}
569}
570
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500571// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500572// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800573type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700574 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800575 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800576 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700577 compilerProps() []interface{}
578
Colin Cross76fada02016-07-27 10:31:13 -0700579 appendCflags([]string)
580 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700581 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800582}
583
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500584// linker is the interface for a linker decorator object. Individual module types can provide
585// their own implementation for this decorator, and thus specify custom logic regarding build
586// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800587type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700588 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800589 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700590 linkerFlags(ctx ModuleContext, flags Flags) Flags
591 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800592 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700593
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700594 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700595 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900596 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700597
598 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900599 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000600
601 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000602 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
603}
604
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500605// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000606type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500607 sharedLibs []string
608 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
609 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700610 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800611}
612
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500613// installer is the interface for an installer helper object. This helper is responsible for
614// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800615type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700616 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700617 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000618 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800619 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700620 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700621 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900622 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000623 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900624 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800625}
626
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800627type xref interface {
628 XrefCcFiles() android.Paths
629}
630
Inseob Kima1888ce2022-10-04 14:42:02 +0900631type overridable interface {
632 overriddenModules() []string
633}
634
Colin Cross6e511a92020-07-27 21:26:48 -0700635type libraryDependencyKind int
636
637const (
638 headerLibraryDependency = iota
639 sharedLibraryDependency
640 staticLibraryDependency
641)
642
643func (k libraryDependencyKind) String() string {
644 switch k {
645 case headerLibraryDependency:
646 return "headerLibraryDependency"
647 case sharedLibraryDependency:
648 return "sharedLibraryDependency"
649 case staticLibraryDependency:
650 return "staticLibraryDependency"
651 default:
652 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
653 }
654}
655
656type libraryDependencyOrder int
657
658const (
659 earlyLibraryDependency = -1
660 normalLibraryDependency = 0
661 lateLibraryDependency = 1
662)
663
664func (o libraryDependencyOrder) String() string {
665 switch o {
666 case earlyLibraryDependency:
667 return "earlyLibraryDependency"
668 case normalLibraryDependency:
669 return "normalLibraryDependency"
670 case lateLibraryDependency:
671 return "lateLibraryDependency"
672 default:
673 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
674 }
675}
676
677// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
678// tags that have a set of predefined tag objects that are reused for each dependency, a
679// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
680// That means that comparing a libraryDependencyTag for equality will only be equal if all
681// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
682// then check individual metadata fields instead.
683type libraryDependencyTag struct {
684 blueprint.BaseDependencyTag
685
686 // These are exported so that fmt.Printf("%#v") can call their String methods.
687 Kind libraryDependencyKind
688 Order libraryDependencyOrder
689
690 wholeStatic bool
691
692 reexportFlags bool
693 explicitlyVersioned bool
694 dataLib bool
695 ndk bool
696
697 staticUnwinder bool
698
699 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900700
Cindy Zhou18417cb2020-12-10 07:12:38 -0800701 // Whether or not this dependency should skip the apex dependency check
702 skipApexAllowedDependenciesCheck bool
703
Jiyong Parke3867542020-12-03 17:28:25 +0900704 // Whether or not this dependency has to be followed for the apex variants
705 excludeInApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000706
707 // If true, don't automatically export symbols from the static library into a shared library.
708 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700709}
710
711// header returns true if the libraryDependencyTag is tagging a header lib dependency.
712func (d libraryDependencyTag) header() bool {
713 return d.Kind == headerLibraryDependency
714}
715
716// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
717func (d libraryDependencyTag) shared() bool {
718 return d.Kind == sharedLibraryDependency
719}
720
721// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
722func (d libraryDependencyTag) static() bool {
723 return d.Kind == staticLibraryDependency
724}
725
Colin Cross65cb3142021-12-10 23:05:02 +0000726func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
727 if d.shared() {
728 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
729 }
730 return nil
731}
732
733var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
734
Colin Crosse9fe2942020-11-10 18:12:15 -0800735// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
736// binaries or other shared libraries are installed as dependencies.
737func (d libraryDependencyTag) InstallDepNeeded() bool {
738 return d.shared()
739}
740
741var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
742
743// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700744// libraryDependencyTag. Each tag object is created globally and reused for multiple
745// dependencies (although since the object contains no references, assigning a tag to a
746// variable and modifying it will not modify the original). Users can compare the tag
747// returned by ctx.OtherModuleDependencyTag against the global original
748type dependencyTag struct {
749 blueprint.BaseDependencyTag
750 name string
751}
752
Colin Crosse9fe2942020-11-10 18:12:15 -0800753// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
754// libraryDependencyTag, but where the dependency needs to be installed when the parent is
755// installed.
756type installDependencyTag struct {
757 blueprint.BaseDependencyTag
758 android.InstallAlwaysNeededDependencyTag
759 name string
760}
761
Colin Crossc99deeb2016-04-11 15:06:20 -0700762var (
Colin Cross6e511a92020-07-27 21:26:48 -0700763 genSourceDepTag = dependencyTag{name: "gen source"}
764 genHeaderDepTag = dependencyTag{name: "gen header"}
765 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
766 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900767 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700768 reuseObjTag = dependencyTag{name: "reuse objects"}
769 staticVariantTag = dependencyTag{name: "static variant"}
770 vndkExtDepTag = dependencyTag{name: "vndk extends"}
771 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700772 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800773 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700774 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700775 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000776 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500777 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400778 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700779)
780
Roland Levillainf89cd092019-07-29 16:22:59 +0100781func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700782 ccLibDepTag, ok := depTag.(libraryDependencyTag)
783 return ok && ccLibDepTag.shared()
784}
785
786func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
787 ccLibDepTag, ok := depTag.(libraryDependencyTag)
788 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100789}
790
Zach Johnson3df4e632020-11-06 11:56:27 -0800791func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
792 ccLibDepTag, ok := depTag.(libraryDependencyTag)
793 return ok && ccLibDepTag.header()
794}
795
Roland Levillainf89cd092019-07-29 16:22:59 +0100796func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800797 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100798}
799
800func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700801 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100802 return ok && ccDepTag == testPerSrcDepTag
803}
804
Chris Parsonsf874e462022-05-10 13:50:12 -0400805// bazelHandler is the interface for a helper object related to deferring to Bazel for
806// processing a cc module (during Bazel mixed builds). Individual module types should define
807// their own bazel handler if they support being handled by Bazel.
808type BazelHandler interface {
809 // QueueBazelCall invokes request-queueing functions on the BazelContext
810 //so that these requests are handled when Bazel's cquery is invoked.
811 QueueBazelCall(ctx android.BaseModuleContext, label string)
812
813 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
814 // on the current module with given label.
815 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
816}
817
Colin Crossca860ac2016-01-04 14:34:37 -0800818// Module contains the properties and members used by all C/C++ module types, and implements
819// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500820// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
821// interface.
822//
823// To define a C/C++ related module, construct a new Module object and point its delegates to
824// type-specific structs. These delegates will be invoked to register module-specific build
825// statements which may be unique to the module type. For example, module.compiler.compile() should
826// be defined so as to register build statements which are responsible for compiling the module.
827//
828// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
829// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
830// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
831// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800832type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700833 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700834
Liz Kammerea6666f2021-02-17 10:17:28 -0500835 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700836
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700837 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700838 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700839
Colin Crossca860ac2016-01-04 14:34:37 -0800840 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400841 hod android.HostOrDeviceSupported
842 multilib android.Multilib
843 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700844
Paul Duffina0843f62019-12-13 19:50:38 +0000845 // Allowable SdkMemberTypes of this module type.
846 sdkMemberTypes []android.SdkMemberType
847
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500848 // decorator delegates, initialize before calling Init
849 // these may contain module-specific implementations, and effectively allow for custom
850 // type-specific logic. These members may reference different objects or the same object.
851 // Functions of these decorators will be invoked to initialize and register type-specific
852 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500853 compiler compiler
854 linker linker
855 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400856 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500857
858 features []feature
859 stl *stl
860 sanitize *sanitize
861 coverage *coverage
Cory Barkera1da26f2022-06-07 20:12:06 +0000862 fuzzer *fuzzer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500863 sabi *sabi
864 vndkdep *vndkdep
865 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800866 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500867 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800868
Colin Cross31076b32020-10-23 17:22:06 -0700869 library libraryInterface
870
Colin Cross635c3b02016-05-18 15:37:25 -0700871 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800872
Colin Crossb98c8b02016-07-29 13:44:28 -0700873 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700874
875 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800876
877 // Flags used to compile this module
878 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700879
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800880 // Shared flags among build rules of this module
881 sharedFlags SharedFlags
882
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800883 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700884 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900885
886 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800887 // Kythe (source file indexer) paths for this compilation module
888 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700889 // Object .o file output paths for this compilation module
890 objFiles android.Paths
891 // Tidy .tidy file output paths for this compilation module
892 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900893
894 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700895 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700896
897 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700898}
899
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200900func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400901 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
902 if b, ok := c.compiler.(*baseCompiler); ok {
903 hasAidl = b.hasSrcExt(".aidl")
904 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
905 hasProto = b.hasSrcExt(".proto")
906 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
907 hasSysprop = b.hasSrcExt(".sysprop")
908 hasWinMsg = b.hasSrcExt(".mc")
909 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
910 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200911 c.AndroidModuleBase().AddJSONData(d)
912 (*d)["Cc"] = map[string]interface{}{
913 "SdkVersion": c.SdkVersion(),
914 "MinSdkVersion": c.MinSdkVersion(),
915 "VndkVersion": c.VndkVersion(),
916 "ProductSpecific": c.ProductSpecific(),
917 "SocSpecific": c.SocSpecific(),
918 "DeviceSpecific": c.DeviceSpecific(),
919 "InProduct": c.InProduct(),
920 "InVendor": c.InVendor(),
921 "InRamdisk": c.InRamdisk(),
922 "InVendorRamdisk": c.InVendorRamdisk(),
923 "InRecovery": c.InRecovery(),
924 "VendorAvailable": c.VendorAvailable(),
925 "ProductAvailable": c.ProductAvailable(),
926 "RamdiskAvailable": c.RamdiskAvailable(),
927 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
928 "RecoveryAvailable": c.RecoveryAvailable(),
929 "OdmAvailable": c.OdmAvailable(),
930 "InstallInData": c.InstallInData(),
931 "InstallInRamdisk": c.InstallInRamdisk(),
932 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
933 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
934 "InstallInRecovery": c.InstallInRecovery(),
935 "InstallInRoot": c.InstallInRoot(),
936 "IsVndk": c.IsVndk(),
937 "IsVndkExt": c.IsVndkExt(),
938 "IsVndkPrivate": c.IsVndkPrivate(),
939 "IsVndkSp": c.IsVndkSp(),
940 "IsLlndk": c.IsLlndk(),
941 "IsLlndkPublic": c.IsLlndkPublic(),
942 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
943 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
944 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
945 "ApexSdkVersion": c.apexSdkVersion,
946 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400947 "AidlSrcs": hasAidl,
948 "LexSrcs": hasLex,
949 "ProtoSrcs": hasProto,
950 "RenderscriptSrcs": hasRenderscript,
951 "SyspropSrcs": hasSysprop,
952 "WinMsgSrcs": hasWinMsg,
953 "YaccSrsc": hasYacc,
954 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200955 }
956}
957
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500958func (c *Module) SetPreventInstall() {
959 c.Properties.PreventInstall = true
960}
961
962func (c *Module) SetHideFromMake() {
963 c.Properties.HideFromMake = true
964}
965
Ivan Lozanod7586b62021-04-01 09:49:36 -0400966func (c *Module) HiddenFromMake() bool {
967 return c.Properties.HideFromMake
968}
969
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800970func (c *Module) RequiredModuleNames() []string {
971 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
972 if c.ImageVariation().Variation == android.CoreVariation {
973 required = append(required, c.Properties.Target.Platform.Required...)
974 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
975 } else if c.InRecovery() {
976 required = append(required, c.Properties.Target.Recovery.Required...)
977 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
978 }
979 return android.FirstUniqueStrings(required)
980}
981
Ivan Lozano52767be2019-10-18 14:49:46 -0700982func (c *Module) Toc() android.OptionalPath {
983 if c.linker != nil {
984 if library, ok := c.linker.(libraryInterface); ok {
985 return library.toc()
986 }
987 }
988 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
989}
990
991func (c *Module) ApiLevel() string {
992 if c.linker != nil {
993 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700994 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700995 }
996 }
997 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
998}
999
1000func (c *Module) Static() bool {
1001 if c.linker != nil {
1002 if library, ok := c.linker.(libraryInterface); ok {
1003 return library.static()
1004 }
1005 }
1006 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1007}
1008
1009func (c *Module) Shared() bool {
1010 if c.linker != nil {
1011 if library, ok := c.linker.(libraryInterface); ok {
1012 return library.shared()
1013 }
1014 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001015
Ivan Lozano52767be2019-10-18 14:49:46 -07001016 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1017}
1018
1019func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001020 if c.stl != nil {
1021 return c.stl.Properties.SelectedStl
1022 }
1023 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001024}
1025
Ivan Lozano52767be2019-10-18 14:49:46 -07001026func (c *Module) NdkPrebuiltStl() bool {
1027 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1028 return true
1029 }
1030 return false
1031}
1032
1033func (c *Module) StubDecorator() bool {
1034 if _, ok := c.linker.(*stubDecorator); ok {
1035 return true
1036 }
1037 return false
1038}
1039
1040func (c *Module) SdkVersion() string {
1041 return String(c.Properties.Sdk_version)
1042}
1043
Artur Satayev480e25b2020-04-27 18:53:18 +01001044func (c *Module) MinSdkVersion() string {
1045 return String(c.Properties.Min_sdk_version)
1046}
1047
Jiyong Park5df7bd32021-08-25 16:18:46 +09001048func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001049 if linker, ok := c.linker.(*objectLinker); ok {
1050 return linker.isCrt()
1051 }
1052 return false
1053}
1054
Jiyong Park5df7bd32021-08-25 16:18:46 +09001055func (c *Module) SplitPerApiLevel() bool {
1056 return c.canUseSdk() && c.isCrt()
1057}
1058
Colin Crossc511bc52020-04-07 16:50:32 +00001059func (c *Module) AlwaysSdk() bool {
1060 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1061}
1062
Ivan Lozano183a3212019-10-18 14:18:45 -07001063func (c *Module) CcLibrary() bool {
1064 if c.linker != nil {
1065 if _, ok := c.linker.(*libraryDecorator); ok {
1066 return true
1067 }
Colin Crossd48fe732020-09-23 20:37:24 -07001068 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1069 return true
1070 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001071 }
1072 return false
1073}
1074
1075func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001076 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001077 return true
1078 }
1079 return false
1080}
1081
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001082func (c *Module) RlibStd() bool {
1083 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1084}
1085
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001086func (c *Module) RustLibraryInterface() bool {
1087 return false
1088}
1089
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001090func (c *Module) IsFuzzModule() bool {
1091 if _, ok := c.compiler.(*fuzzBinary); ok {
1092 return true
1093 }
1094 return false
1095}
1096
1097func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1098 return c.FuzzModule
1099}
1100
1101func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1102 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1103 return fuzzer.fuzzPackagedModule
1104 }
1105 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1106}
1107
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001108func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001109 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1110 return fuzzer.sharedLibraries
1111 }
1112 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1113}
1114
Ivan Lozano2b262972019-11-21 12:30:50 -08001115func (c *Module) NonCcVariants() bool {
1116 return false
1117}
1118
Ivan Lozano183a3212019-10-18 14:18:45 -07001119func (c *Module) SetStatic() {
1120 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001121 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001122 library.setStatic()
1123 return
1124 }
1125 }
1126 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1127}
1128
1129func (c *Module) SetShared() {
1130 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001131 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001132 library.setShared()
1133 return
1134 }
1135 }
1136 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1137}
1138
1139func (c *Module) BuildStaticVariant() bool {
1140 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001141 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001142 return library.buildStatic()
1143 }
1144 }
1145 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1146}
1147
1148func (c *Module) BuildSharedVariant() bool {
1149 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001150 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001151 return library.buildShared()
1152 }
1153 }
1154 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1155}
1156
1157func (c *Module) Module() android.Module {
1158 return c
1159}
1160
Jiyong Parkc20eee32018-09-05 22:36:17 +09001161func (c *Module) OutputFile() android.OptionalPath {
1162 return c.outputFile
1163}
1164
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001165func (c *Module) CoverageFiles() android.Paths {
1166 if c.linker != nil {
1167 if library, ok := c.linker.(libraryInterface); ok {
1168 return library.objs().coverageFiles
1169 }
1170 }
1171 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1172}
1173
Ivan Lozano183a3212019-10-18 14:18:45 -07001174var _ LinkableInterface = (*Module)(nil)
1175
Jiyong Park719b4462019-01-13 00:39:51 +09001176func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001177 if c.linker != nil {
1178 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001179 }
1180 return nil
1181}
1182
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001183func (c *Module) CoverageOutputFile() android.OptionalPath {
1184 if c.linker != nil {
1185 return c.linker.coverageOutputFilePath()
1186 }
1187 return android.OptionalPath{}
1188}
1189
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001190func (c *Module) RelativeInstallPath() string {
1191 if c.installer != nil {
1192 return c.installer.relativeInstallPath()
1193 }
1194 return ""
1195}
1196
Jooyung Han344d5432019-08-23 11:17:39 +09001197func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001198 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001199}
1200
Colin Cross36242852017-06-23 15:06:31 -07001201func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001202 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001203 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001204 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001205 }
1206 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001207 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001208 }
1209 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001210 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001211 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001212 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001213 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001214 }
Colin Cross16b23492016-01-06 14:41:07 -08001215 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001216 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001217 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001218 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001219 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001220 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001221 if c.fuzzer != nil {
1222 c.AddProperties(c.fuzzer.props()...)
1223 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001224 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001225 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001226 }
Justin Yun8effde42017-06-23 19:24:43 +09001227 if c.vndkdep != nil {
1228 c.AddProperties(c.vndkdep.props()...)
1229 }
Stephen Craneba090d12017-05-09 15:44:35 -07001230 if c.lto != nil {
1231 c.AddProperties(c.lto.props()...)
1232 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001233 if c.afdo != nil {
1234 c.AddProperties(c.afdo.props()...)
1235 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001236 if c.pgo != nil {
1237 c.AddProperties(c.pgo.props()...)
1238 }
Colin Crossca860ac2016-01-04 14:34:37 -08001239 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001240 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001241 }
Colin Crossc472d572015-03-17 15:06:21 -07001242
Colin Cross36242852017-06-23 15:06:31 -07001243 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001244 if c.bazelable {
1245 android.InitBazelModule(c)
1246 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001247 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001248 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001249
Colin Cross36242852017-06-23 15:06:31 -07001250 return c
Colin Crossc472d572015-03-17 15:06:21 -07001251}
1252
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001253// UseVndk() returns true if this module is built against VNDK.
1254// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001255func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001256 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001257}
1258
Colin Crossc511bc52020-04-07 16:50:32 +00001259func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001260 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1261 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001262}
1263
1264func (c *Module) UseSdk() bool {
1265 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001266 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001267 }
1268 return false
1269}
1270
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001271func (c *Module) isCoverageVariant() bool {
1272 return c.coverage.Properties.IsCoverageVariant
1273}
1274
Colin Cross95f1ca02020-10-29 20:47:22 -07001275func (c *Module) IsNdk(config android.Config) bool {
1276 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001277}
1278
Colin Cross127bb8b2020-12-16 16:46:01 -08001279func (c *Module) IsLlndk() bool {
1280 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001281}
1282
Colin Cross127bb8b2020-12-16 16:46:01 -08001283func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001284 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001285}
1286
Colin Cross1f3f1302021-04-26 18:37:44 -07001287func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001288 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001289 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001290}
1291
Colin Cross5271fea2021-04-27 13:06:04 -07001292func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1293 lib := moduleLibraryInterface(m)
1294 return lib != nil && (lib.hasVendorPublicLibrary())
1295}
1296
1297// IsVendorPublicLibrary returns true for vendor public libraries.
1298func (c *Module) IsVendorPublicLibrary() bool {
1299 return c.VendorProperties.IsVendorPublicLibrary
1300}
1301
Ivan Lozanof1868af2022-04-12 13:08:36 -04001302func (c *Module) IsVndkPrebuiltLibrary() bool {
1303 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1304 return true
1305 }
1306 return false
1307}
1308
1309func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1310 return c.Properties.SdkAndPlatformVariantVisibleToMake
1311}
1312
Ivan Lozanod7586b62021-04-01 09:49:36 -04001313func (c *Module) HasLlndkStubs() bool {
1314 lib := moduleLibraryInterface(c)
1315 return lib != nil && lib.hasLLNDKStubs()
1316}
1317
1318func (c *Module) StubsVersion() string {
1319 if lib, ok := c.linker.(versionedInterface); ok {
1320 return lib.stubsVersion()
1321 }
1322 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1323}
1324
Colin Cross127bb8b2020-12-16 16:46:01 -08001325// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1326// and does not set llndk.vendor_available: false.
1327func (c *Module) isImplementationForLLNDKPublic() bool {
1328 library, _ := c.library.(*libraryDecorator)
1329 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001330 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001331}
1332
Justin Yunfd9e8042020-12-23 18:23:14 +09001333// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001334func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001335 // Check if VNDK-core-private or VNDK-SP-private
1336 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001337 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001338 }
1339
1340 // Check if LLNDK-private
1341 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001342 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001343 }
1344
1345 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001346}
1347
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001348// IsVndk() returns true if this module has a vndk variant.
1349// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1350// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001351func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001352 if vndkdep := c.vndkdep; vndkdep != nil {
1353 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001354 }
1355 return false
1356}
1357
Yi Kong4ef54592022-02-14 20:00:10 +08001358func (c *Module) isAfdoCompile() bool {
1359 if afdo := c.afdo; afdo != nil {
Vinh Tran44cb78c2023-03-09 22:07:19 -05001360 return afdo.Properties.FdoProfilePath != nil
Yi Kong4ef54592022-02-14 20:00:10 +08001361 }
1362 return false
1363}
1364
Yi Kong7e53c572018-02-14 18:16:12 +08001365func (c *Module) isPgoCompile() bool {
1366 if pgo := c.pgo; pgo != nil {
1367 return pgo.Properties.PgoCompile
1368 }
1369 return false
1370}
1371
Yi Kongc702ebd2022-08-19 16:02:45 +08001372func (c *Module) isCfi() bool {
1373 if sanitize := c.sanitize; sanitize != nil {
1374 return Bool(sanitize.Properties.Sanitize.Cfi)
1375 }
1376 return false
1377}
1378
Yi Konged79fa32023-06-04 17:15:42 +09001379func (c *Module) isFuzzer() bool {
1380 if sanitize := c.sanitize; sanitize != nil {
1381 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1382 }
1383 return false
1384}
1385
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001386func (c *Module) isNDKStubLibrary() bool {
1387 if _, ok := c.compiler.(*stubDecorator); ok {
1388 return true
1389 }
1390 return false
1391}
1392
Ivan Lozanod7586b62021-04-01 09:49:36 -04001393func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001394 if vndkdep := c.vndkdep; vndkdep != nil {
1395 return vndkdep.isVndkSp()
1396 }
1397 return false
1398}
1399
Ivan Lozanof9e21722020-12-02 09:00:51 -05001400func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001401 if vndkdep := c.vndkdep; vndkdep != nil {
1402 return vndkdep.isVndkExt()
1403 }
1404 return false
1405}
1406
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001407func (c *Module) SubName() string {
1408 return c.Properties.SubName
1409}
1410
Ivan Lozano52767be2019-10-18 14:49:46 -07001411func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001412 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001413}
1414
Logan Chienf3511742017-10-31 18:04:35 +08001415func (c *Module) getVndkExtendsModuleName() string {
1416 if vndkdep := c.vndkdep; vndkdep != nil {
1417 return vndkdep.getVndkExtendsModuleName()
1418 }
1419 return ""
1420}
1421
Jiyong Park25fc6a92018-11-18 18:02:45 +09001422func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001423 if lib := c.library; lib != nil {
1424 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001425 }
1426 return false
1427}
1428
1429func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001430 if lib := c.library; lib != nil {
1431 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001432 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001433 return false
1434}
1435
Alan Stokes73feba32022-11-14 12:21:24 +00001436func (c *Module) IsStubsImplementationRequired() bool {
1437 if lib := c.library; lib != nil {
1438 return lib.isStubsImplementationRequired()
1439 }
1440 return false
1441}
1442
Colin Cross0477b422020-10-13 18:43:54 -07001443// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1444// the implementation. If it is an implementation library it returns its own name.
1445func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1446 name := ctx.OtherModuleName(c)
1447 if versioned, ok := c.linker.(versionedInterface); ok {
1448 name = versioned.implementationModuleName(name)
1449 }
1450 return name
1451}
1452
Martin Stjernholm2856c662020-12-02 15:03:42 +00001453// Similar to ImplementationModuleName, but uses the Make variant of the module
1454// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1455// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1456// under the premise that the prebuilt module overrides its source counterpart
1457// if it is exposed to Make).
1458func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1459 name := c.BaseModuleName()
1460 if versioned, ok := c.linker.(versionedInterface); ok {
1461 name = versioned.implementationModuleName(name)
1462 }
1463 return name
1464}
1465
Jiyong Park7d55b612021-06-11 17:22:09 +09001466func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001467 return Bool(c.Properties.Bootstrap)
1468}
1469
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001470func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001471 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1472 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1473 return false
1474 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001475 return c.linker != nil && c.linker.nativeCoverage()
1476}
1477
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001478func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001479 if p, ok := c.linker.(SnapshotInterface); ok {
1480 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001481 }
1482 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001483}
1484
Bill Peckham945441c2020-08-31 16:07:58 -07001485func (c *Module) ExcludeFromVendorSnapshot() bool {
1486 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1487}
1488
Jose Galmesf7294582020-11-13 12:07:36 -08001489func (c *Module) ExcludeFromRecoverySnapshot() bool {
1490 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1491}
1492
Jiyong Parkf1194352019-02-25 11:05:47 +09001493func isBionic(name string) bool {
1494 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001495 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001496 return true
1497 }
1498 return false
1499}
1500
Martin Stjernholm279de572019-09-10 23:18:20 +01001501func InstallToBootstrap(name string, config android.Config) bool {
Jingwen Chen29743c82023-01-25 17:49:46 +00001502 // NOTE: also update //build/bazel/rules/apex/cc.bzl#_installed_to_bootstrap
1503 // if this list is updated.
Florian Mayer95cd6db2023-03-23 17:48:07 -07001504 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001505 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001506 }
1507 return isBionic(name)
1508}
1509
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001510func (c *Module) XrefCcFiles() android.Paths {
1511 return c.kytheFiles
1512}
1513
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001514func (c *Module) isCfiAssemblySupportEnabled() bool {
1515 return c.sanitize != nil &&
1516 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1517}
1518
Inseob Kim800d1142021-06-14 12:03:51 +09001519func (c *Module) InstallInRoot() bool {
1520 return c.installer != nil && c.installer.installInRoot()
1521}
1522
Colin Crossca860ac2016-01-04 14:34:37 -08001523type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001524 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001525 moduleContextImpl
1526}
1527
Colin Cross37047f12016-12-13 17:06:13 -08001528type depsContext struct {
1529 android.BottomUpMutatorContext
1530 moduleContextImpl
1531}
1532
Colin Crossca860ac2016-01-04 14:34:37 -08001533type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001534 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001535 moduleContextImpl
1536}
1537
1538type moduleContextImpl struct {
1539 mod *Module
1540 ctx BaseModuleContext
1541}
1542
Colin Crossb98c8b02016-07-29 13:44:28 -07001543func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001544 return ctx.mod.toolchain(ctx.ctx)
1545}
1546
1547func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001548 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001549}
1550
1551func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001552 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001553}
1554
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001555func (ctx *moduleContextImpl) testBinary() bool {
1556 return ctx.mod.testBinary()
1557}
1558
Yi Kong56fc1b62022-09-06 16:24:00 +08001559func (ctx *moduleContextImpl) testLibrary() bool {
1560 return ctx.mod.testLibrary()
1561}
1562
Jiyong Park1d1119f2019-07-29 21:27:18 +09001563func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001564 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001565}
1566
Inseob Kim7f283f42020-06-01 21:53:49 +09001567func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001568 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001569}
1570
Inseob Kim1042d292020-06-01 23:23:05 +09001571func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001572 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001573}
1574
Jooyung Hanccce2f22020-03-07 03:45:53 +09001575func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001576 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001577}
1578
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001579func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001580 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001581}
1582
1583func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001584 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001585 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001586 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001587 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001588 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001589 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001590 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001591 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001592 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001593 }
1594 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001595}
1596
Jiyong Parkb35a8192020-08-10 15:59:36 +09001597func (ctx *moduleContextImpl) minSdkVersion() string {
1598 ver := ctx.mod.MinSdkVersion()
1599 if ver == "apex_inherit" && !ctx.isForPlatform() {
1600 ver = ctx.apexSdkVersion().String()
1601 }
1602 if ver == "apex_inherit" || ver == "" {
1603 ver = ctx.sdkVersion()
1604 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001605 // For crt objects, the meaning of min_sdk_version is very different from other types of
1606 // module. For them, min_sdk_version defines the oldest version that the build system will
1607 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1608 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1609 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001610 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1611 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1612 // support such an old version. The version is set to the later version in case when the
1613 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1614 // it's for an APEX.
1615 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1616 if ctx.isForPlatform() {
1617 ver = strconv.Itoa(android.FutureApiLevelInt)
1618 } else { // for apex
1619 ver = ctx.apexSdkVersion().String()
1620 if ver == "" { // in case when min_sdk_version was not set by the APEX
1621 ver = ctx.sdkVersion()
1622 }
1623 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001624 }
1625
Jiyong Parkb35a8192020-08-10 15:59:36 +09001626 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1627 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1628 minSdkVersionInt, err2 := strconv.Atoi(ver)
1629 if err == nil && err2 == nil {
1630 if sdkVersionInt < minSdkVersionInt {
1631 return strconv.Itoa(sdkVersionInt)
1632 }
1633 }
1634 return ver
1635}
1636
1637func (ctx *moduleContextImpl) isSdkVariant() bool {
1638 return ctx.mod.IsSdkVariant()
1639}
1640
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001641func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001642 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001643}
Justin Yun8effde42017-06-23 19:24:43 +09001644
Colin Cross95f1ca02020-10-29 20:47:22 -07001645func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1646 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001647}
1648
Colin Cross127bb8b2020-12-16 16:46:01 -08001649func (ctx *moduleContextImpl) IsLlndk() bool {
1650 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001651}
1652
Colin Cross127bb8b2020-12-16 16:46:01 -08001653func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1654 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001655}
1656
Colin Cross127bb8b2020-12-16 16:46:01 -08001657func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1658 return ctx.mod.isImplementationForLLNDKPublic()
1659}
1660
1661func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1662 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001663}
1664
Logan Chienf3511742017-10-31 18:04:35 +08001665func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001666 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001667}
1668
Yi Kong4ef54592022-02-14 20:00:10 +08001669func (ctx *moduleContextImpl) isAfdoCompile() bool {
1670 return ctx.mod.isAfdoCompile()
1671}
1672
Yi Kong7e53c572018-02-14 18:16:12 +08001673func (ctx *moduleContextImpl) isPgoCompile() bool {
1674 return ctx.mod.isPgoCompile()
1675}
1676
Yi Kongc702ebd2022-08-19 16:02:45 +08001677func (ctx *moduleContextImpl) isCfi() bool {
1678 return ctx.mod.isCfi()
1679}
1680
Yi Konged79fa32023-06-04 17:15:42 +09001681func (ctx *moduleContextImpl) isFuzzer() bool {
1682 return ctx.mod.isFuzzer()
1683}
1684
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001685func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1686 return ctx.mod.isNDKStubLibrary()
1687}
1688
Justin Yun8effde42017-06-23 19:24:43 +09001689func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001690 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001691}
1692
Ivan Lozanof9e21722020-12-02 09:00:51 -05001693func (ctx *moduleContextImpl) IsVndkExt() bool {
1694 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001695}
1696
Colin Cross5271fea2021-04-27 13:06:04 -07001697func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1698 return ctx.mod.IsVendorPublicLibrary()
1699}
1700
Vic Yangefd249e2018-11-12 20:19:56 -08001701func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001702 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001703}
1704
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001705func (ctx *moduleContextImpl) selectedStl() string {
1706 if stl := ctx.mod.stl; stl != nil {
1707 return stl.Properties.SelectedStl
1708 }
1709 return ""
1710}
1711
Ivan Lozanobd721262018-11-27 14:33:03 -08001712func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1713 return ctx.mod.linker.useClangLld(actx)
1714}
1715
Colin Crossce75d2c2016-10-06 16:12:58 -07001716func (ctx *moduleContextImpl) baseModuleName() string {
1717 return ctx.mod.ModuleBase.BaseModuleName()
1718}
1719
Logan Chienf3511742017-10-31 18:04:35 +08001720func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1721 return ctx.mod.getVndkExtendsModuleName()
1722}
1723
Logan Chiene274fc92019-12-03 11:18:32 -08001724func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001725 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001726}
1727
Colin Crosse07f2312020-08-13 11:24:56 -07001728func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001729 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001730}
1731
Dan Albertc8060532020-07-22 22:32:17 -07001732func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001733 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001734}
1735
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001736func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001737 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001738}
1739
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001740func (ctx *moduleContextImpl) nativeCoverage() bool {
1741 return ctx.mod.nativeCoverage()
1742}
1743
Colin Cross56a83212020-09-15 18:30:11 -07001744func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1745 return ctx.mod.DirectlyInAnyApex()
1746}
1747
Colin Cross95b07f22020-12-16 11:06:50 -08001748func (ctx *moduleContextImpl) isPreventInstall() bool {
1749 return ctx.mod.Properties.PreventInstall
1750}
1751
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001752func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1753 shared := &ctx.mod.sharedFlags
1754 if shared.flagsMap == nil {
1755 shared.numSharedFlags = 0
1756 shared.flagsMap = make(map[string]string)
1757 }
1758 return shared
1759}
1760
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001761func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1762 return ctx.mod.isCfiAssemblySupportEnabled()
1763}
1764
Colin Cross635c3b02016-05-18 15:37:25 -07001765func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001766 return &Module{
1767 hod: hod,
1768 multilib: multilib,
1769 }
1770}
1771
Colin Cross635c3b02016-05-18 15:37:25 -07001772func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001773 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001774 module.features = []feature{
1775 &tidyFeature{},
1776 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001777 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001778 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001779 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001780 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001781 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001782 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001783 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001784 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001785 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001786 return module
1787}
1788
Colin Crossce75d2c2016-10-06 16:12:58 -07001789func (c *Module) Prebuilt() *android.Prebuilt {
1790 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1791 return p.prebuilt()
1792 }
1793 return nil
1794}
1795
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001796func (c *Module) IsPrebuilt() bool {
1797 return c.Prebuilt() != nil
1798}
1799
Colin Crossce75d2c2016-10-06 16:12:58 -07001800func (c *Module) Name() string {
1801 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001802 if p, ok := c.linker.(interface {
1803 Name(string) string
1804 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001805 name = p.Name(name)
1806 }
1807 return name
1808}
1809
Alex Light3d673592019-01-18 14:37:31 -08001810func (c *Module) Symlinks() []string {
1811 if p, ok := c.installer.(interface {
1812 symlinkList() []string
1813 }); ok {
1814 return p.symlinkList()
1815 }
1816 return nil
1817}
1818
Roland Levillainf89cd092019-07-29 16:22:59 +01001819func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1820 test, ok := c.linker.(testPerSrc)
1821 return ok && test.isAllTestsVariation()
1822}
1823
Chris Parsons216e10a2020-07-09 17:12:52 -04001824func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001825 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001826 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001827 }); ok {
1828 return p.dataPaths()
1829 }
1830 return nil
1831}
1832
Ivan Lozanof1868af2022-04-12 13:08:36 -04001833func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001834 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1835 // "current", it will append the VNDK version to the name suffix.
1836 var vndkVersion string
1837 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001838 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001839 if c.ProductSpecific() {
1840 // If the module is product specific with 'product_specific: true',
1841 // do not add a name suffix because it is a base module.
1842 return ""
1843 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001844 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001845 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001846 } else {
1847 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001848 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001849 }
1850 if vndkVersion == "current" {
1851 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1852 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001853 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001854 // add version suffix only if the module is using different vndk version than the
1855 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001856 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001857 }
1858 return nameSuffix
1859}
1860
Ivan Lozanof1868af2022-04-12 13:08:36 -04001861func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1862 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001863
1864 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001865 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001866 }
1867
Colin Cross127bb8b2020-12-16 16:46:01 -08001868 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001869 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001870 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1871 // added for product variant only when we have vendor and product variants with core
1872 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001873 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001874 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001875 subName += vendorPublicLibrarySuffix
1876 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001877 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1878 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001879 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001880 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001881 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001882 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001883 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001884 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001885 subName += RecoverySuffix
1886 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1887 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001888 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001889 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001890 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001891 } else if c.IsStubs() && c.IsSdkVariant() {
1892 // Public API surface (NDK)
1893 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1894 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001895 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001896
1897 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001898}
1899
Chris Parsonsf874e462022-05-10 13:50:12 -04001900var _ android.MixedBuildBuildable = (*Module)(nil)
1901
1902func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001903 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001904 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001905 // cc_library is a special case in bp2build; two targets are generated -- one for each
1906 // of the shared and static variants. The shared variant keeps the module name, but the
1907 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001908 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1909 } else {
1910 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001911 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001912 labelNoPrebuilt := bazelModuleLabel
1913 if c.IsPrebuilt() {
1914 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1915 }
1916 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001917}
1918
1919func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1920 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1921}
1922
Jingwen Chen3952a902022-12-12 12:20:58 +00001923// IsMixedBuildSupported returns true if the module should be analyzed by Bazel
Jingwen Chena485d092023-04-20 12:34:08 +00001924// in any of the --bazel-mode(s).
Chris Parsonsf874e462022-05-10 13:50:12 -04001925func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
Yu Liu8860c6c2023-06-07 12:43:26 -07001926 if !allEnabledSanitizersSupportedByBazel(ctx, c) {
Sam Delmericoef69d472023-04-18 17:32:43 -04001927 //TODO(b/278772861) support sanitizers in Bazel rules
Yu Liue4312402023-01-18 09:15:31 -08001928 return false
1929 }
Liz Kammer1cec9d12023-06-22 10:09:47 -04001930 if !imageVariantSupportedByBazel(c) {
1931 return false
1932 }
1933 if c.IsSdkVariant() {
1934 return false
1935 }
Sam Delmericoef69d472023-04-18 17:32:43 -04001936 return c.bazelHandler != nil
1937}
1938
Liz Kammer1cec9d12023-06-22 10:09:47 -04001939func imageVariantSupportedByBazel(c *Module) bool {
1940 if c.IsLlndk() {
1941 return false
1942 }
1943 if c.InVendor() {
1944 return false
1945 }
1946 if c.InProduct() {
1947 return false
1948 }
1949 if c.InRamdisk() {
1950 return false
1951 }
1952 if c.InVendorRamdisk() {
1953 return false
1954 }
1955 if c.InRecovery() {
1956 return false
1957 }
1958 return true
1959}
1960
Yu Liu8860c6c2023-06-07 12:43:26 -07001961func allEnabledSanitizersSupportedByBazel(ctx android.BaseModuleContext, c *Module) bool {
Sam Delmericoef69d472023-04-18 17:32:43 -04001962 if c.sanitize == nil {
1963 return true
1964 }
Yu Liue4312402023-01-18 09:15:31 -08001965 sanitizeProps := &c.sanitize.Properties.SanitizeMutated
Sam Delmericoef69d472023-04-18 17:32:43 -04001966
1967 unsupportedSanitizers := []*bool{
1968 sanitizeProps.Safestack,
Sam Delmericoef69d472023-04-18 17:32:43 -04001969 sanitizeProps.Scudo,
1970 BoolPtr(len(c.sanitize.Properties.Sanitize.Recover) > 0),
Sam Delmericoef69d472023-04-18 17:32:43 -04001971 }
1972 for _, san := range unsupportedSanitizers {
1973 if Bool(san) {
1974 return false
1975 }
1976 }
1977
1978 for _, san := range Sanitizers {
1979 if san == intOverflow {
1980 // TODO(b/261058727): enable mixed builds for all modules with UBSan
1981 // Currently we can only support ubsan when minimum runtime is used.
1982 ubsanEnabled := Bool(sanitizeProps.Integer_overflow) || len(sanitizeProps.Misc_undefined) > 0
Yu Liu8860c6c2023-06-07 12:43:26 -07001983 if !ubsanEnabled || c.MinimalRuntimeNeeded() {
1984 continue
Sam Delmericoef69d472023-04-18 17:32:43 -04001985 }
Yu Liu95497dc2023-05-25 11:15:07 -07001986 } else if san == cfi {
Yu Liu8860c6c2023-06-07 12:43:26 -07001987 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1988 // Only allow cfi if this is an apex variant
1989 if !apexInfo.IsForPlatform() {
1990 continue
1991 }
1992 }
1993 if c.sanitize.isSanitizerEnabled(san) {
Sam Delmericoef69d472023-04-18 17:32:43 -04001994 return false
1995 }
1996 }
1997
1998 return true
Yu Liue4312402023-01-18 09:15:31 -08001999}
2000
2001func GetApexConfigKey(ctx android.BaseModuleContext) *android.ApexConfigKey {
2002 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2003 if !apexInfo.IsForPlatform() {
2004 apexKey := android.ApexConfigKey{
2005 WithinApex: true,
2006 ApexSdkVersion: findApexSdkVersion(ctx, apexInfo).String(),
Spandan Das40b79f82023-06-25 20:56:06 +00002007 ApiDomain: findApiDomain(apexInfo),
Yu Liue4312402023-01-18 09:15:31 -08002008 }
2009 return &apexKey
2010 }
2011
2012 return nil
Chris Parsonsf874e462022-05-10 13:50:12 -04002013}
2014
Spandan Das40b79f82023-06-25 20:56:06 +00002015// Returns the api domain of a module for an apexInfo group
2016// Input:
2017// ai.InApexModules: [com.android.foo, test_com.android.foo, com.google.android.foo]
2018// Return:
2019// com.android.foo
2020
2021// If a module is included in multiple api domains (collated by min_sdk_version), it will return
2022// the first match. The other matches have the same build actions since they share a min_sdk_version, so returning
2023// the first match is fine.
2024func findApiDomain(ai android.ApexInfo) string {
2025 // Remove any test apexes
2026 matches, _ := android.FilterList(ai.InApexModules, ai.TestApexes)
2027 // Remove any google apexes. Rely on naming convention.
2028 pred := func(s string) bool { return !strings.HasPrefix(s, "com.google") }
2029 matches = android.FilterListPred(matches, pred)
2030 if len(matches) > 0 {
2031 // Return the first match
2032 return android.SortedUniqueStrings(matches)[0]
2033 } else {
2034 // No apex in the tree has a dependency on this module
2035 return ""
2036 }
2037}
2038
Chris Parsonsf874e462022-05-10 13:50:12 -04002039func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
2040 bazelModuleLabel := c.getBazelModuleLabel(ctx)
Chris Parsonsf874e462022-05-10 13:50:12 -04002041 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
2042
2043 c.Properties.SubName = GetSubnameProperty(ctx, c)
2044 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2045 if !apexInfo.IsForPlatform() {
2046 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05002047 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05002048
Chris Parsonsf874e462022-05-10 13:50:12 -04002049 c.makeLinkType = GetMakeLinkType(ctx, c)
2050
2051 mctx := &moduleContext{
2052 ModuleContext: ctx,
2053 moduleContextImpl: moduleContextImpl{
2054 mod: c,
2055 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05002056 }
Chris Parsonsf874e462022-05-10 13:50:12 -04002057 mctx.ctx = mctx
2058
Jingwen Chen3952a902022-12-12 12:20:58 +00002059 // TODO(b/244432500): Get the tradefed config from the bazel target instead
2060 // of generating it with Soong.
Chris Parsonsf874e462022-05-10 13:50:12 -04002061 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002062}
2063
Sam Delmerico75dbca22023-04-20 13:13:25 +00002064func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
2065 ctx := &moduleContext{
2066 ModuleContext: actx,
2067 moduleContextImpl: moduleContextImpl{
2068 mod: c,
2069 },
2070 }
2071 ctx.ctx = ctx
2072 return ctx
2073}
2074
Spandan Das20fce2d2023-04-12 17:21:39 +00002075// TODO (b/277651159): Remove this allowlist
2076var (
2077 skipStubLibraryMultipleApexViolation = map[string]bool{
2078 "libclang_rt.asan": true,
2079 "libclang_rt.hwasan": true,
2080 // runtime apex
2081 "libc": true,
2082 "libc_hwasan": true,
2083 "libdl_android": true,
2084 "libm": true,
2085 "libdl": true,
2086 // art apex
2087 "libandroidio": true,
2088 "libdexfile": true,
2089 "libnativebridge": true,
2090 "libnativehelper": true,
2091 "libnativeloader": true,
2092 "libsigchain": true,
2093 }
2094)
2095
2096// Returns true if a stub library could be installed in multiple apexes
2097func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
2098 // If this is not an apex variant, no check necessary
2099 if !c.InAnyApex() {
2100 return false
2101 }
2102 // If this is not a stub library, no check necessary
2103 if !c.HasStubsVariants() {
2104 return false
2105 }
2106 // Skip the allowlist
2107 // Use BaseModuleName so that this matches prebuilts.
2108 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
2109 return false
2110 }
2111
2112 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
2113 // Stub libraries should not have more than one apex_available
2114 if len(aaWithoutTestApexes) > 1 {
2115 return true
2116 }
2117 // Stub libraries should not use the wildcard
2118 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
2119 return true
2120 }
2121 // Default: no violation
2122 return false
2123}
2124
Chris Parsons8d6e4332021-02-22 16:13:50 -05002125func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05002126 // Handle the case of a test module split by `test_per_src` mutator.
2127 //
2128 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
2129 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
2130 // module and return early, as this module does not produce an output file per se.
2131 if c.IsTestPerSrcAllTestsVariation() {
2132 c.outputFile = android.OptionalPath{}
2133 return
2134 }
2135
Ivan Lozanof1868af2022-04-12 13:08:36 -04002136 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002137 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2138 if !apexInfo.IsForPlatform() {
2139 c.hideApexVariantFromMake = true
2140 }
2141
Chris Parsonseefc9e62021-04-02 17:36:47 -04002142 c.makeLinkType = GetMakeLinkType(actx, c)
2143
Sam Delmerico75dbca22023-04-20 13:13:25 +00002144 ctx := moduleContextFromAndroidModuleContext(actx, c)
Colin Crossca860ac2016-01-04 14:34:37 -08002145
Colin Crossf18e1102017-11-16 14:33:08 -08002146 deps := c.depsToPaths(ctx)
2147 if ctx.Failed() {
2148 return
2149 }
2150
Spandan Das20fce2d2023-04-12 17:21:39 +00002151 if c.stubLibraryMultipleApexViolation(actx) {
2152 actx.PropertyErrorf("apex_available",
2153 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
2154 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002155 if c.Properties.Clang != nil && *c.Properties.Clang == false {
2156 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00002157 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
2158 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002159 }
2160
Colin Crossca860ac2016-01-04 14:34:37 -08002161 flags := Flags{
2162 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002163 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002164 }
Colin Crossca860ac2016-01-04 14:34:37 -08002165 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002166 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002167 }
2168 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002169 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002170 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002171 if c.stl != nil {
2172 flags = c.stl.flags(ctx, flags)
2173 }
Colin Cross16b23492016-01-06 14:41:07 -08002174 if c.sanitize != nil {
2175 flags = c.sanitize.flags(ctx, flags)
2176 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002177 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002178 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002179 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002180 if c.fuzzer != nil {
2181 flags = c.fuzzer.flags(ctx, flags)
2182 }
Stephen Craneba090d12017-05-09 15:44:35 -07002183 if c.lto != nil {
2184 flags = c.lto.flags(ctx, flags)
2185 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002186 if c.afdo != nil {
2187 flags = c.afdo.flags(ctx, flags)
2188 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002189 if c.pgo != nil {
2190 flags = c.pgo.flags(ctx, flags)
2191 }
Colin Crossca860ac2016-01-04 14:34:37 -08002192 for _, feature := range c.features {
2193 flags = feature.flags(ctx, flags)
2194 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002195 if ctx.Failed() {
2196 return
2197 }
2198
Colin Cross4af21ed2019-11-04 09:37:55 -08002199 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2200 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2201 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002202
Colin Cross4af21ed2019-11-04 09:37:55 -08002203 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002204
2205 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002206 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002207 }
2208 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002209 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002210 }
2211
Colin Cross3e5e7782022-06-17 22:17:05 +00002212 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2213
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002214 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002215 // We need access to all the flags seen by a source file.
2216 if c.sabi != nil {
2217 flags = c.sabi.flags(ctx, flags)
2218 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002219
Colin Cross4af21ed2019-11-04 09:37:55 -08002220 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002221
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002222 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002223 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002224 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002225 if ctx.Failed() {
2226 return
2227 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002228 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002229 c.objFiles = objs.objFiles
2230 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002231 }
2232
Colin Crossca860ac2016-01-04 14:34:37 -08002233 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002234 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002235 if ctx.Failed() {
2236 return
2237 }
Colin Cross635c3b02016-05-18 15:37:25 -07002238 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002239
Chris Parsons94a0bba2021-06-04 15:03:47 -04002240 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002241
Jose Galmes6f843bc2020-12-11 13:36:29 -08002242 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2243 // RECOVERY_SNAPSHOT_VERSION is current.
2244 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002245 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002246 i.collectHeadersForSnapshot(ctx)
2247 }
2248 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002249 }
Colin Cross5049f022015-03-18 13:28:46 -07002250
Chris Parsons94a0bba2021-06-04 15:03:47 -04002251 c.maybeInstall(ctx, apexInfo)
2252}
2253
2254func (c *Module) maybeUnhideFromMake() {
2255 // If a lib is directly included in any of the APEXes or is not available to the
2256 // platform (which is often the case when the stub is provided as a prebuilt),
2257 // unhide the stubs variant having the latest version gets visible to make. In
2258 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2259 // force anything in the make world to link against the stubs library. (unless it
2260 // is explicitly referenced via .bootstrap suffix or the module is marked with
2261 // 'bootstrap: true').
2262 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2263 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2264 c.IsStubs() && !c.InVendorRamdisk() {
2265 c.Properties.HideFromMake = false // unhide
2266 // Note: this is still non-installable
2267 }
2268}
2269
Jingwen Chen3952a902022-12-12 12:20:58 +00002270// maybeInstall is called at the end of both GenerateAndroidBuildActions and
2271// ProcessBazelQueryResponse to run the install hooks for installable modules,
2272// like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002273func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002274 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002275 // If the module has been specifically configure to not be installed then
2276 // hide from make as otherwise it will break when running inside make
2277 // as the output path to install will not be specified. Not all uninstallable
2278 // modules can be hidden from make as some are needed for resolving make side
2279 // dependencies.
2280 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002281 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002282 c.SkipInstall()
2283 }
2284
2285 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2286 // to allow using the outputs in a genrule.
2287 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002288 c.installer.install(ctx, c.outputFile.Path())
2289 if ctx.Failed() {
2290 return
Colin Crossca860ac2016-01-04 14:34:37 -08002291 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002292 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002293}
2294
Sam Delmerico5fb794a2023-01-27 16:01:37 -05002295func (c *Module) setAndroidMkVariablesFromCquery(info cquery.CcAndroidMkInfo) {
2296 c.Properties.AndroidMkSharedLibs = info.LocalSharedLibs
2297 c.Properties.AndroidMkStaticLibs = info.LocalStaticLibs
2298 c.Properties.AndroidMkWholeStaticLibs = info.LocalWholeStaticLibs
2299}
2300
Colin Cross0ea8ba82019-06-06 14:33:29 -07002301func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002302 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002303 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002304 }
Colin Crossca860ac2016-01-04 14:34:37 -08002305 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002306}
2307
Colin Crossca860ac2016-01-04 14:34:37 -08002308func (c *Module) begin(ctx BaseModuleContext) {
2309 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002310 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002311 }
Colin Crossca860ac2016-01-04 14:34:37 -08002312 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002313 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002314 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002315 if c.stl != nil {
2316 c.stl.begin(ctx)
2317 }
Colin Cross16b23492016-01-06 14:41:07 -08002318 if c.sanitize != nil {
2319 c.sanitize.begin(ctx)
2320 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002321 if c.coverage != nil {
2322 c.coverage.begin(ctx)
2323 }
Stephen Craneba090d12017-05-09 15:44:35 -07002324 if c.lto != nil {
2325 c.lto.begin(ctx)
2326 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002327 if c.pgo != nil {
2328 c.pgo.begin(ctx)
2329 }
Dan Albert92fe7402020-07-15 13:33:30 -07002330 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002331 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002332 if err != nil {
2333 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002334 c.Properties.Sdk_version = nil
2335 } else {
2336 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002337 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002338 }
Colin Crossca860ac2016-01-04 14:34:37 -08002339}
2340
Colin Cross37047f12016-12-13 17:06:13 -08002341func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002342 deps := Deps{}
2343
2344 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002345 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002346 }
2347 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002348 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002349 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002350 if c.stl != nil {
2351 deps = c.stl.deps(ctx, deps)
2352 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002353 if c.coverage != nil {
2354 deps = c.coverage.deps(ctx, deps)
2355 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002356
Colin Crossb6715442017-10-24 11:13:31 -07002357 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2358 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2359 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2360 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2361 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2362 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002363 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002364
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002365 for _, lib := range deps.ReexportSharedLibHeaders {
2366 if !inList(lib, deps.SharedLibs) {
2367 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2368 }
2369 }
2370
2371 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002372 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2373 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 -07002374 }
2375 }
2376
Colin Cross5950f382016-12-13 12:50:57 -08002377 for _, lib := range deps.ReexportHeaderLibHeaders {
2378 if !inList(lib, deps.HeaderLibs) {
2379 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2380 }
2381 }
2382
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002383 for _, gen := range deps.ReexportGeneratedHeaders {
2384 if !inList(gen, deps.GeneratedHeaders) {
2385 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2386 }
2387 }
2388
Colin Crossc99deeb2016-04-11 15:06:20 -07002389 return deps
2390}
2391
Dan Albert7e9d2952016-08-04 13:02:36 -07002392func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002393 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002394 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002395 moduleContextImpl: moduleContextImpl{
2396 mod: c,
2397 },
2398 }
2399 ctx.ctx = ctx
2400
Vinh Tran44cb78c2023-03-09 22:07:19 -05002401 if !actx.Host() || !ctx.static() || ctx.staticBinary() {
2402 c.afdo.addDep(ctx, actx)
2403 }
2404
Colin Crossca860ac2016-01-04 14:34:37 -08002405 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002406}
2407
Jiyong Park7ed9de32018-10-15 22:25:07 +09002408// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002409func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002410 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2411 version := name[sharp+1:]
2412 libname := name[:sharp]
2413 return libname, version
2414 }
2415 return name, ""
2416}
2417
Dan Albert92fe7402020-07-15 13:33:30 -07002418func GetCrtVariations(ctx android.BottomUpMutatorContext,
2419 m LinkableInterface) []blueprint.Variation {
2420 if ctx.Os() != android.Android {
2421 return nil
2422 }
2423 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002424 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2425 minSdkVersion := m.MinSdkVersion()
2426 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2427 minSdkVersion = m.SdkVersion()
2428 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002429 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2430 if err != nil {
2431 ctx.PropertyErrorf("min_sdk_version", err.Error())
2432 }
Colin Cross363ec762023-01-13 13:45:14 -08002433
2434 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002435 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002436 if apiLevel.LessThan(minApiForArch) {
2437 apiLevel = minApiForArch
2438 }
2439
Dan Albert92fe7402020-07-15 13:33:30 -07002440 return []blueprint.Variation{
2441 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002442 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002443 }
2444 }
2445 return []blueprint.Variation{
2446 {Mutator: "sdk", Variation: ""},
2447 }
2448}
2449
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002450func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2451 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002452
2453 variations = append([]blueprint.Variation(nil), variations...)
2454
Liz Kammer23942242022-04-08 15:41:00 -04002455 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002456 // Version is explicitly specified. i.e. libFoo#30
2457 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002458 if tag, ok := depTag.(libraryDependencyTag); ok {
2459 tag.explicitlyVersioned = true
2460 } else {
2461 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2462 }
Colin Crosse7257d22020-09-24 09:56:18 -07002463 }
Colin Crosse7257d22020-09-24 09:56:18 -07002464
Colin Cross0de8a1e2020-09-18 14:15:30 -07002465 if far {
2466 ctx.AddFarVariationDependencies(variations, depTag, name)
2467 } else {
2468 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002469 }
2470}
2471
Kiyoung Kim487689e2022-07-26 09:48:22 +09002472func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2473 apiImportInfo := multitree.ApiImportInfo{}
2474
2475 if c.Device() {
2476 var apiImportModule []blueprint.Module
2477 if actx.OtherModuleExists("api_imports") {
2478 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2479 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2480 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2481 apiImportInfo = apiInfo
2482 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2483 }
2484 }
2485 }
2486
2487 return apiImportInfo
2488}
2489
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002490func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002491 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002492 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002493 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002494 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2495 // between the modules in the snapshot and the snapshot itself.
2496 var snapshotModule []blueprint.Module
2497 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2498 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2499 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2500 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2501 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002502 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002503 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2504 *snapshotInfo = &snapshot
2505 // republish the snapshot for use in later mutators on this module
2506 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002507 }
2508 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002509 if *snapshotInfo == nil {
2510 *snapshotInfo = &SnapshotInfo{}
2511 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002512 return **snapshotInfo
2513}
2514
Kiyoung Kim487689e2022-07-26 09:48:22 +09002515func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2516 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002517 return snapshot
2518 }
2519
2520 return lib
2521}
2522
2523// RewriteLibs takes a list of names of shared libraries and scans it for three types
2524// of names:
2525//
2526// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002527//
2528// For each of these, it adds the name of the prebuilt module (which will be in
2529// prebuilts/ndk) to the list of nonvariant libs.
2530//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002531// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002532//
2533// For each of these, it adds the name of the ndk_library module to the list of
2534// variant libs.
2535//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002536// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002537//
2538// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002539//
2540// The caller can then know to add the variantLibs dependencies differently from the
2541// nonvariantLibs
2542func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2543 variantLibs = []string{}
2544
2545 nonvariantLibs = []string{}
2546 for _, entry := range list {
2547 // strip #version suffix out
2548 name, _ := StubsLibNameAndVersion(entry)
2549 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002550 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002551 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2552 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2553 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002554 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002555 } else {
2556 // put name#version back
2557 nonvariantLibs = append(nonvariantLibs, entry)
2558 }
2559 }
2560 return nonvariantLibs, variantLibs
2561}
2562
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002563func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2564 nonVariantLibs := []string{}
2565 variantLibs := []string{}
2566
2567 for _, lib := range libs {
2568 replaceLibName := GetReplaceModuleName(lib, replaceList)
2569 if replaceLibName == lib {
2570 // Do not handle any libs which are not in API imports
2571 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2572 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2573 variantLibs = append(variantLibs, replaceLibName)
2574 } else {
2575 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2576 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002577 }
2578
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002579 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002580}
2581
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002582func (c *Module) shouldUseApiSurface() bool {
2583 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2584 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2585 // LLNDK Variant
2586 return true
2587 }
2588
2589 if c.Properties.IsSdkVariant {
2590 // NDK Variant
2591 return true
2592 }
2593
2594 if c.isImportedApiLibrary() {
2595 // API Library should depend on API headers
2596 return true
2597 }
2598 }
2599
2600 return false
2601}
2602
Colin Cross1e676be2016-10-12 14:38:15 -07002603func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002604 if !c.Enabled() {
2605 return
2606 }
2607
Colin Cross37047f12016-12-13 17:06:13 -08002608 ctx := &depsContext{
2609 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002610 moduleContextImpl: moduleContextImpl{
2611 mod: c,
2612 },
2613 }
2614 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002615
Colin Crossc99deeb2016-04-11 15:06:20 -07002616 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002617 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002618
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002619 apiNdkLibs := []string{}
2620 apiLateNdkLibs := []string{}
2621
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002622 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002623 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2624 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2625 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2626 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2627 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002628 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002629
Yo Chiang219968c2020-09-22 18:45:04 +08002630 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2631
Colin Crosse0edaf92021-01-11 17:31:17 -08002632 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002633
Dan Albert914449f2016-06-17 16:45:24 -07002634 variantNdkLibs := []string{}
2635 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002636 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002637 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2638 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2639 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002640
2641 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002642 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002643 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002644 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002645
Colin Cross32ec36c2016-12-15 07:39:51 -08002646 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002647 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002648 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002649 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002650 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002651
Kiyoung Kim51279d32022-08-24 14:10:46 +09002652 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002653 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002654 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2655 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002656 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002657
Spandan Das73bcafc2022-08-18 23:26:00 +00002658 if c.isNDKStubLibrary() {
2659 // ndk_headers do not have any variations
2660 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002661 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002662 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002663 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002664 } else {
2665 actx.AddVariationDependencies(nil, depTag, lib)
2666 }
2667 }
2668
Dan Albertf1d14c72020-07-30 14:32:55 -07002669 if c.isNDKStubLibrary() {
2670 // NDK stubs depend on their implementation because the ABI dumps are
2671 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002672
Spandan Das8b08aea2023-03-14 19:29:34 +00002673 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2674 c.ImageVariation(),
2675 blueprint.Variation{Mutator: "link", Variation: "shared"},
2676 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002677 }
2678
Jiyong Park5d1598f2019-02-25 22:14:17 +09002679 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002680 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002681
Kiyoung Kim487689e2022-07-26 09:48:22 +09002682 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002683
Jiyong Park5d1598f2019-02-25 22:14:17 +09002684 actx.AddVariationDependencies([]blueprint.Variation{
2685 {Mutator: "link", Variation: "static"},
2686 }, depTag, lib)
2687 }
2688
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002689 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002690 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002691 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002692 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002693 }
Jiyong Parke3867542020-12-03 17:28:25 +09002694 if inList(lib, deps.ExcludeLibsForApex) {
2695 depTag.excludeInApex = true
2696 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002697
Kiyoung Kim487689e2022-07-26 09:48:22 +09002698 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002699
Dan Willemsen59339a22018-07-22 21:18:45 -07002700 actx.AddVariationDependencies([]blueprint.Variation{
2701 {Mutator: "link", Variation: "static"},
2702 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002703 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002704
Jooyung Han75568392020-03-20 04:29:24 +09002705 // staticUnwinderDep is treated as staticDep for Q apexes
2706 // so that native libraries/binaries are linked with static unwinder
2707 // because Q libc doesn't have unwinder APIs
2708 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002709 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002710 actx.AddVariationDependencies([]blueprint.Variation{
2711 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002712 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002713 }
2714
Jiyong Park7ed9de32018-10-15 22:25:07 +09002715 // shared lib names without the #version suffix
2716 var sharedLibNames []string
2717
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002718 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002719 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002720 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002721 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002722 }
Jiyong Parke3867542020-12-03 17:28:25 +09002723 if inList(lib, deps.ExcludeLibsForApex) {
2724 depTag.excludeInApex = true
2725 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002726
Jiyong Park73c54ee2019-10-22 20:31:18 +09002727 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002728 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2729 name = apiLibraryName
2730 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002731 sharedLibNames = append(sharedLibNames, name)
2732
Colin Crosse7257d22020-09-24 09:56:18 -07002733 variations := []blueprint.Variation{
2734 {Mutator: "link", Variation: "shared"},
2735 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002736
2737 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2738 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2739 }
2740
2741 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2742 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2743 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002744 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002745
Colin Crossfe9acfe2021-06-14 16:13:03 -07002746 for _, lib := range deps.LateStaticLibs {
2747 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2748 actx.AddVariationDependencies([]blueprint.Variation{
2749 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002750 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002751 }
2752
Colin Cross3e5e7782022-06-17 22:17:05 +00002753 for _, lib := range deps.UnexportedStaticLibs {
2754 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2755 actx.AddVariationDependencies([]blueprint.Variation{
2756 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002757 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002758 }
2759
Jiyong Park7ed9de32018-10-15 22:25:07 +09002760 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002761 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002762 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2763 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2764 // linking against both the stubs lib and the non-stubs lib at the same time.
2765 continue
2766 }
Colin Cross6e511a92020-07-27 21:26:48 -07002767 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002768 variations := []blueprint.Variation{
2769 {Mutator: "link", Variation: "shared"},
2770 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002771 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002772 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002773
Dan Willemsen59339a22018-07-22 21:18:45 -07002774 actx.AddVariationDependencies([]blueprint.Variation{
2775 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002776 }, dataLibDepTag, deps.DataLibs...)
2777
Colin Crossc8caa062021-09-24 16:50:14 -07002778 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2779
Chris Parsons79d66a52020-06-05 17:26:16 -04002780 actx.AddVariationDependencies([]blueprint.Variation{
2781 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002782 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002783
Colin Cross68861832016-07-08 10:41:41 -07002784 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002785
2786 for _, gen := range deps.GeneratedHeaders {
2787 depTag := genHeaderDepTag
2788 if inList(gen, deps.ReexportGeneratedHeaders) {
2789 depTag = genHeaderExportDepTag
2790 }
2791 actx.AddDependency(c, depTag, gen)
2792 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002793
Dan Albert92fe7402020-07-15 13:33:30 -07002794 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002795 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002796 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002797 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002798 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002799 }
Colin Crossc465efd2021-06-11 18:00:04 -07002800 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002801 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002802 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002803 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002804 if deps.DynamicLinker != "" {
2805 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002806 }
Dan Albert914449f2016-06-17 16:45:24 -07002807
2808 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002809
2810 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002811 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002812 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002813 {Mutator: "link", Variation: "shared"},
2814 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002815 actx.AddVariationDependencies([]blueprint.Variation{
2816 {Mutator: "version", Variation: version},
2817 {Mutator: "link", Variation: "shared"},
2818 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002819
2820 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002821 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002822 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002823 {Mutator: "link", Variation: "shared"},
2824 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002825 actx.AddVariationDependencies([]blueprint.Variation{
2826 {Mutator: "version", Variation: version},
2827 {Mutator: "link", Variation: "shared"},
2828 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002829
2830 if vndkdep := c.vndkdep; vndkdep != nil {
2831 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002832 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002833 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002834 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002835 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002836 }
2837 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002838
Vinh Tran367d89d2023-04-28 11:21:25 -04002839 if len(deps.AidlLibs) > 0 {
2840 actx.AddDependency(
2841 c,
2842 aidlLibraryTag,
2843 deps.AidlLibs...,
2844 )
2845 }
2846
Kiyoung Kimee58c932022-10-25 22:59:41 +09002847 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002848}
Colin Cross21b9a242015-03-24 14:15:58 -07002849
Colin Crosse40b4ea2018-10-02 22:25:58 -07002850func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002851 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2852 c.beginMutator(ctx)
2853 }
2854}
2855
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002856// Whether a module can link to another module, taking into
2857// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002858func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002859 tag blueprint.DependencyTag) {
2860
2861 switch t := tag.(type) {
2862 case dependencyTag:
2863 if t != vndkExtDepTag {
2864 return
2865 }
2866 case libraryDependencyTag:
2867 default:
2868 return
2869 }
2870
Ivan Lozanof9e21722020-12-02 09:00:51 -05002871 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002872 // Host code is not restricted
2873 return
2874 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002875
2876 // VNDK is cc.Module supported only for now.
2877 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002878 // Though allowed dependency is limited by the image mutator,
2879 // each vendor and product module needs to check link-type
2880 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002881 if ccTo, ok := to.(*Module); ok {
2882 if ccFrom.vndkdep != nil {
2883 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2884 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002885 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002886 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002887 }
2888 return
2889 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002890 // TODO(b/244244438) : Remove this once all variants are implemented
2891 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2892 return
2893 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002894 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002895 // Platform code can link to anything
2896 return
2897 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002898 if from.InRamdisk() {
2899 // Ramdisk code is not NDK
2900 return
2901 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002902 if from.InVendorRamdisk() {
2903 // Vendor ramdisk code is not NDK
2904 return
2905 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002906 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002907 // Recovery code is not NDK
2908 return
2909 }
Colin Cross31076b32020-10-23 17:22:06 -07002910 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002911 if c.NdkPrebuiltStl() {
2912 // These are allowed, but they don't set sdk_version
2913 return
2914 }
2915 if c.StubDecorator() {
2916 // These aren't real libraries, but are the stub shared libraries that are included in
2917 // the NDK.
2918 return
2919 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002920 if c.isImportedApiLibrary() {
2921 // Imported library from the API surface is a stub library built against interface definition.
2922 return
2923 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002924 }
Logan Chien834b9a62019-01-14 15:39:03 +08002925
Ivan Lozano52767be2019-10-18 14:49:46 -07002926 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002927 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2928 // to link to libc++ (non-NDK and without sdk_version).
2929 return
2930 }
2931
Ivan Lozano52767be2019-10-18 14:49:46 -07002932 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002933 // NDK code linking to platform code is never okay.
2934 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002935 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002936 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002937 }
2938
2939 // At this point we know we have two NDK libraries, but we need to
2940 // check that we're not linking against anything built against a higher
2941 // API level, as it is only valid to link against older or equivalent
2942 // APIs.
2943
Inseob Kim01a28722018-04-11 09:48:45 +09002944 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002945 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002946 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002947 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002948 // Current can't be linked against by anything else.
2949 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002950 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002951 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002952 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002953 if err != nil {
2954 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002955 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002956 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002957 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002958 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002959 if err != nil {
2960 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002961 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002962 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002963 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002964
Inseob Kim01a28722018-04-11 09:48:45 +09002965 if toApi > fromApi {
2966 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002967 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002968 }
2969 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002970 }
Dan Albert202fe492017-12-15 13:56:59 -08002971
2972 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002973 fromStl := from.SelectedStl()
2974 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002975 if fromStl == "" || toStl == "" {
2976 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002977 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002978 // We can be permissive with the system "STL" since it is only the C++
2979 // ABI layer, but in the future we should make sure that everyone is
2980 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002981 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002982 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002983 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2984 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002985 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002986}
2987
Jooyung Han479ca172020-10-19 18:51:07 +09002988func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2989 if c, ok := ctx.Module().(*Module); ok {
2990 ctx.VisitDirectDeps(func(dep android.Module) {
2991 depTag := ctx.OtherModuleDependencyTag(dep)
2992 ccDep, ok := dep.(LinkableInterface)
2993 if ok {
2994 checkLinkType(ctx, c, ccDep, depTag)
2995 }
2996 })
2997 }
2998}
2999
Jiyong Park5fb8c102018-04-09 12:03:06 +09003000// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09003001// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
3002// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09003003// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09003004func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
3005 check := func(child, parent android.Module) bool {
3006 to, ok := child.(*Module)
3007 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09003008 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09003009 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09003010
Jooyung Hana70f0672019-01-18 15:20:43 +09003011 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
3012 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09003013 }
Jooyung Hana70f0672019-01-18 15:20:43 +09003014
Jiyong Park0474e1f2021-01-14 14:26:06 +09003015 // These dependencies are not excercised at runtime. Tracking these will give us
3016 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09003017 depTag := ctx.OtherModuleDependencyTag(child)
3018 if IsHeaderDepTag(depTag) {
3019 return false
3020 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09003021 if depTag == staticVariantTag {
3022 return false
3023 }
3024 if depTag == stubImplDepTag {
3025 return false
3026 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003027
Justin Yun63e9ec72020-10-29 16:49:43 +09003028 // Even if target lib has no vendor variant, keep checking dependency
3029 // graph in case it depends on vendor_available or product_available
3030 // but not double_loadable transtively.
3031 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09003032 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09003033 }
Jooyung Hana70f0672019-01-18 15:20:43 +09003034
Jiyong Park0474e1f2021-01-14 14:26:06 +09003035 // The happy path. Keep tracking dependencies until we hit a non double-loadable
3036 // one.
3037 if Bool(to.VendorProperties.Double_loadable) {
3038 return true
3039 }
3040
Ivan Lozanod7586b62021-04-01 09:49:36 -04003041 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09003042 return false
3043 }
3044
Jooyung Hana70f0672019-01-18 15:20:43 +09003045 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
3046 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09003047 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09003048 return false
3049 }
3050 if module, ok := ctx.Module().(*Module); ok {
3051 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09003052 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09003053 ctx.WalkDeps(check)
3054 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09003055 }
3056 }
3057}
3058
Yu Liue4312402023-01-18 09:15:31 -08003059func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
3060 // For the dependency from platform to apex, use the latest stubs
3061 apexSdkVersion := android.FutureApiLevel
3062 if !apexInfo.IsForPlatform() {
3063 apexSdkVersion = apexInfo.MinSdkVersion
3064 }
3065
3066 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
3067 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
3068 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
3069 // (b/144430859)
3070 apexSdkVersion = android.FutureApiLevel
3071 }
3072
3073 return apexSdkVersion
3074}
3075
Colin Crossc99deeb2016-04-11 15:06:20 -07003076// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07003077func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08003078 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08003079
Colin Cross0de8a1e2020-09-18 14:15:30 -07003080 var directStaticDeps []StaticLibraryInfo
3081 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07003082
Colin Cross0de8a1e2020-09-18 14:15:30 -07003083 reexportExporter := func(exporter FlagExporterInfo) {
3084 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
3085 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
3086 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
3087 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
3088 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09003089 }
3090
Colin Cross56a83212020-09-15 18:30:11 -07003091 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Yu Liue4312402023-01-18 09:15:31 -08003092 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09003093
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003094 skipModuleList := map[string]bool{}
3095
3096 var apiImportInfo multitree.ApiImportInfo
3097 hasApiImportInfo := false
3098
3099 ctx.VisitDirectDeps(func(dep android.Module) {
3100 if dep.Name() == "api_imports" {
3101 apiImportInfo = ctx.OtherModuleProvider(dep, multitree.ApiImportsProvider).(multitree.ApiImportInfo)
3102 hasApiImportInfo = true
3103 }
3104 })
3105
3106 if hasApiImportInfo {
3107 targetStubModuleList := map[string]string{}
3108 targetOrigModuleList := map[string]string{}
3109
3110 // Search for dependency which both original module and API imported library with APEX stub exists
3111 ctx.VisitDirectDeps(func(dep android.Module) {
3112 depName := ctx.OtherModuleName(dep)
3113 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
3114 targetStubModuleList[apiLibrary] = depName
3115 }
3116 })
3117 ctx.VisitDirectDeps(func(dep android.Module) {
3118 depName := ctx.OtherModuleName(dep)
3119 if origLibrary, ok := targetStubModuleList[depName]; ok {
3120 targetOrigModuleList[origLibrary] = depName
3121 }
3122 })
3123
3124 // Decide which library should be used between original and API imported library
3125 ctx.VisitDirectDeps(func(dep android.Module) {
3126 depName := ctx.OtherModuleName(dep)
3127 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00003128 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003129 skipModuleList[depName] = true
3130 } else {
3131 skipModuleList[apiLibrary] = true
3132 }
3133 }
3134 })
3135 }
3136
Colin Crossd11fcda2017-10-23 17:59:01 -07003137 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003138 depName := ctx.OtherModuleName(dep)
3139 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07003140
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003141 if _, ok := skipModuleList[depName]; ok {
3142 // skip this module because original module or API imported module matching with this should be used instead.
3143 return
3144 }
3145
Dan Willemsen47450072021-10-19 20:24:49 -07003146 if depTag == android.DarwinUniversalVariantTag {
3147 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3148 return
3149 }
3150
Vinh Tran367d89d2023-04-28 11:21:25 -04003151 if depTag == aidlLibraryTag {
3152 if ctx.OtherModuleHasProvider(dep, aidl_library.AidlLibraryProvider) {
3153 depPaths.AidlLibraryInfos = append(
3154 depPaths.AidlLibraryInfos,
3155 ctx.OtherModuleProvider(
3156 dep,
3157 aidl_library.AidlLibraryProvider).(aidl_library.AidlLibraryInfo),
3158 )
3159 }
3160 }
3161
Ivan Lozano52767be2019-10-18 14:49:46 -07003162 ccDep, ok := dep.(LinkableInterface)
3163 if !ok {
3164
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003165 // handling for a few module types that aren't cc Module but that are also supported
3166 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003167 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003168 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003169 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3170 genRule.GeneratedSourceFiles()...)
3171 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003172 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003173 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003174 // Support exported headers from a generated_sources dependency
3175 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003176 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003177 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003178 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003179 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003180 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003181 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003182 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003183 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003184 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3185 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003186 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003187 // 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 +09003188 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003189
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003190 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003191 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003192 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003193 }
Colin Crosscef792e2021-06-11 18:01:26 -07003194 case CrtBeginDepTag:
3195 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3196 case CrtEndDepTag:
3197 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003198 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003199 return
3200 }
3201
Colin Crossfe17f6f2019-03-28 19:30:56 -07003202 if depTag == android.ProtoPluginDepTag {
3203 return
3204 }
3205
Colin Crossd11fcda2017-10-23 17:59:01 -07003206 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003207 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3208 return
3209 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003210 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003211 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3212 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003213 return
3214 }
3215
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003216 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003217 // Skip reused objects for stub libraries, they use their own stub object file instead.
3218 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3219 // version mutator, so the stubs variant is created from the shared variant that
3220 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003221 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07003222 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3223 objs := staticAnalogue.ReuseObjects
3224 depPaths.Objs = depPaths.Objs.Append(objs)
3225 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3226 reexportExporter(depExporterInfo)
3227 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003228 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003229 }
3230
Colin Cross6e511a92020-07-27 21:26:48 -07003231 linkFile := ccDep.OutputFile()
3232
3233 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3234 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003235 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003236 return
3237 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003238
Jiyong Parke3867542020-12-03 17:28:25 +09003239 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3240 return
3241 }
3242
Colin Cross0de8a1e2020-09-18 14:15:30 -07003243 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07003244
Colin Cross6e511a92020-07-27 21:26:48 -07003245 var ptr *android.Paths
3246 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003247
Colin Cross6e511a92020-07-27 21:26:48 -07003248 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003249
Colin Cross6e511a92020-07-27 21:26:48 -07003250 switch {
3251 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08003252 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
3253 if !ctx.Config().AllowMissingDependencies() {
3254 ctx.ModuleErrorf("module %q is not a header library", depName)
3255 } else {
3256 ctx.AddMissingDependencies([]string{depName})
3257 }
3258 return
3259 }
Colin Cross6e511a92020-07-27 21:26:48 -07003260 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003261 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
3262 if !ctx.Config().AllowMissingDependencies() {
3263 ctx.ModuleErrorf("module %q is not a shared library", depName)
3264 } else {
3265 ctx.AddMissingDependencies([]string{depName})
3266 }
3267 return
3268 }
Jiyong Parke3867542020-12-03 17:28:25 +09003269
Jiyong Park7d55b612021-06-11 17:22:09 +09003270 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3271 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003272
Jiyong Park1ad8e162020-12-01 23:40:09 +09003273 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3274 // linkFile, depFile, and ptr.
3275 if c.IsStubs() {
3276 break
3277 }
3278
Colin Cross0de8a1e2020-09-18 14:15:30 -07003279 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3280 depFile = sharedLibraryInfo.TableOfContents
3281
Colin Cross6e511a92020-07-27 21:26:48 -07003282 ptr = &depPaths.SharedLibs
3283 switch libDepTag.Order {
3284 case earlyLibraryDependency:
3285 ptr = &depPaths.EarlySharedLibs
3286 depPtr = &depPaths.EarlySharedLibsDeps
3287 case normalLibraryDependency:
3288 ptr = &depPaths.SharedLibs
3289 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003290 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003291 case lateLibraryDependency:
3292 ptr = &depPaths.LateSharedLibs
3293 depPtr = &depPaths.LateSharedLibsDeps
3294 default:
3295 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003296 }
Colin Cross6e511a92020-07-27 21:26:48 -07003297 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003298 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
3299 if !ctx.Config().AllowMissingDependencies() {
3300 ctx.ModuleErrorf("module %q is not a static library", depName)
3301 } else {
3302 ctx.AddMissingDependencies([]string{depName})
3303 }
3304 return
3305 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003306
3307 // Stubs lib doesn't link to the static lib dependencies. Don't set
3308 // linkFile, depFile, and ptr.
3309 if c.IsStubs() {
3310 break
3311 }
3312
Colin Cross0de8a1e2020-09-18 14:15:30 -07003313 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3314 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003315 if libDepTag.wholeStatic {
3316 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003317 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3318 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003319 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003320 // This case normally catches prebuilt static
3321 // libraries, but it can also occur when
3322 // AllowMissingDependencies is on and the
3323 // dependencies has no sources of its own
3324 // but has a whole_static_libs dependency
3325 // on a missing library. We want to depend
3326 // on the .a file so that there is something
3327 // in the dependency tree that contains the
3328 // error rule for the missing transitive
3329 // dependency.
3330 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003331 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003332 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3333 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003334 } else {
3335 switch libDepTag.Order {
3336 case earlyLibraryDependency:
3337 panic(fmt.Errorf("early static libs not suppported"))
3338 case normalLibraryDependency:
3339 // static dependencies will be handled separately so they can be ordered
3340 // using transitive dependencies.
3341 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003342 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003343 case lateLibraryDependency:
3344 ptr = &depPaths.LateStaticLibs
3345 default:
3346 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003347 }
3348 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003349 if libDepTag.unexportedSymbols {
3350 depPaths.LdFlags = append(depPaths.LdFlags,
3351 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3352 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003353 }
3354
Colin Cross6e511a92020-07-27 21:26:48 -07003355 if libDepTag.static() && !libDepTag.wholeStatic {
3356 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3357 ctx.ModuleErrorf("module %q not a static library", depName)
3358 return
3359 }
Logan Chien43d34c32017-12-20 01:17:32 +08003360
Colin Cross6e511a92020-07-27 21:26:48 -07003361 // When combining coverage files for shared libraries and executables, coverage files
3362 // in static libraries act as if they were whole static libraries. The same goes for
3363 // source based Abi dump files.
3364 if c, ok := ccDep.(*Module); ok {
3365 staticLib := c.linker.(libraryInterface)
3366 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3367 staticLib.objs().coverageFiles...)
3368 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3369 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003370 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003371 // Handle non-CC modules here
3372 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003373 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003374 }
3375 }
3376
Colin Cross6e511a92020-07-27 21:26:48 -07003377 if ptr != nil {
3378 if !linkFile.Valid() {
3379 if !ctx.Config().AllowMissingDependencies() {
3380 ctx.ModuleErrorf("module %q missing output file", depName)
3381 } else {
3382 ctx.AddMissingDependencies([]string{depName})
3383 }
3384 return
3385 }
3386 *ptr = append(*ptr, linkFile.Path())
3387 }
3388
3389 if depPtr != nil {
3390 dep := depFile
3391 if !dep.Valid() {
3392 dep = linkFile
3393 }
3394 *depPtr = append(*depPtr, dep.Path())
3395 }
3396
Colin Cross0de8a1e2020-09-18 14:15:30 -07003397 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3398 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3399 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3400 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3401
3402 if libDepTag.reexportFlags {
3403 reexportExporter(depExporterInfo)
3404 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3405 // Re-exported shared library headers must be included as well since they can help us with type information
3406 // about template instantiations (instantiated from their headers).
3407 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3408 // scripts.
3409 c.sabi.Properties.ReexportedIncludes = append(
3410 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3411 }
3412
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003413 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003414 switch {
3415 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003416 c.Properties.AndroidMkHeaderLibs = append(
3417 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003418 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003419 if lib := moduleLibraryInterface(dep); lib != nil {
3420 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003421 // Add the dependency to the APEX(es) providing the library so that
3422 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003423 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003424 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003425 c.Properties.ApexesProvidingSharedLibs = append(
3426 c.Properties.ApexesProvidingSharedLibs, an)
3427 }
3428 }
3429 }
3430
3431 // Note: the order of libs in this list is not important because
3432 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003433 c.Properties.AndroidMkSharedLibs = append(
3434 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003435 // Record BaseLibName for snapshots.
3436 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003437 case libDepTag.static():
3438 if libDepTag.wholeStatic {
3439 c.Properties.AndroidMkWholeStaticLibs = append(
3440 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3441 } else {
3442 c.Properties.AndroidMkStaticLibs = append(
3443 c.Properties.AndroidMkStaticLibs, makeLibName)
3444 }
Justin Yun5e035862021-06-29 20:50:37 +09003445 // Record BaseLibName for snapshots.
3446 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003447 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003448 } else if !c.IsStubs() {
3449 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3450
Colin Cross6e511a92020-07-27 21:26:48 -07003451 switch depTag {
3452 case runtimeDepTag:
3453 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003454 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003455 // Record BaseLibName for snapshots.
3456 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003457 case objDepTag:
3458 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3459 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003460 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003461 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003462 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003463 case dynamicLinkerDepTag:
3464 depPaths.DynamicLinker = linkFile
3465 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003466 }
Colin Crossca860ac2016-01-04 14:34:37 -08003467 })
3468
Jeff Gaston294356f2017-09-27 17:05:30 -07003469 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003470 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3471 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3472 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003473
Colin Crossdd84e052017-05-17 13:44:16 -07003474 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003475 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003476 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3477 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003478 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003479 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3480 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003481 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003482 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003483 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003484
3485 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003486 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003487 }
Colin Crossdd84e052017-05-17 13:44:16 -07003488
Colin Crossca860ac2016-01-04 14:34:37 -08003489 return depPaths
3490}
3491
Spandan Das604f3762023-03-16 22:51:40 +00003492func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003493 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003494 thisModule, ok := ctx.Module().(android.ApexModule)
3495 if !ok {
3496 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3497 }
3498
3499 useVndk := false
3500 bootstrap := false
3501 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3502 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3503 } else {
3504 useVndk = linkable.UseVndk()
3505 bootstrap = linkable.Bootstrap()
3506 }
3507
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003508 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3509
3510 useStubs := false
3511
3512 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3513 if !apexInfo.IsForPlatform() {
3514 // For platform libraries, use current version of LLNDK
3515 // If this is for use_vendor apex we will apply the same rules
3516 // of apex sdk enforcement below to choose right version.
3517 useStubs = true
3518 }
3519 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3520 // If not building for APEX or the containing APEX allows the use of
3521 // platform APIs, use stubs only when it is from an APEX (and not from
3522 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3523 // bootstrap modules, always link to non-stub variant
3524 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3525
3526 isApexImportedApiLibrary := false
3527
3528 if cc, ok := dep.(*Module); ok {
3529 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3530 if apiLibrary.hasApexStubs() {
3531 isApexImportedApiLibrary = true
3532 }
3533 }
3534 }
3535
3536 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3537
3538 if useStubs {
3539 // Another exception: if this module is a test for an APEX, then
3540 // it is linked with the non-stub variant of a module in the APEX
3541 // as if this is part of the APEX.
3542 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3543 for _, apexContents := range testFor.ApexContents {
3544 if apexContents.DirectlyInApex(depName) {
3545 useStubs = false
3546 break
3547 }
3548 }
3549 }
3550 if useStubs {
3551 // Yet another exception: If this module and the dependency are
3552 // available to the same APEXes then skip stubs between their
3553 // platform variants. This complements the test_for case above,
3554 // which avoids the stubs on a direct APEX library dependency, by
3555 // avoiding stubs for indirect test dependencies as well.
3556 //
3557 // TODO(b/183882457): This doesn't work if the two libraries have
3558 // only partially overlapping apex_available. For that test_for
3559 // modules would need to be split into APEX variants and resolved
3560 // separately for each APEX they have access to.
3561 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3562 useStubs = false
3563 }
3564 }
3565 } else {
3566 // If building for APEX, use stubs when the parent is in any APEX that
3567 // the child is not in.
3568 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3569 }
3570
3571 return useStubs
3572}
3573
3574// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3575// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3576// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3577// has different level of updatability. For example, if a library foo in an APEX depends on a
3578// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3579// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3580// same APEX as foo, the non-stub variant of bar is used.
3581func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3582 depTag := ctx.OtherModuleDependencyTag(dep)
3583 libDepTag, ok := depTag.(libraryDependencyTag)
3584 if !ok || !libDepTag.shared() {
3585 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3586 }
3587
Jiyong Park7d55b612021-06-11 17:22:09 +09003588 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3589 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3590 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Jiyong Park7d55b612021-06-11 17:22:09 +09003591
3592 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003593 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003594 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003595 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3596 toUse := stubs[len(stubs)-1]
3597 sharedLibraryInfo = toUse.SharedLibraryInfo
3598 depExporterInfo = toUse.FlagExporterInfo
3599 }
3600 }
3601 return sharedLibraryInfo, depExporterInfo
3602}
3603
Colin Cross0de8a1e2020-09-18 14:15:30 -07003604// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3605// to match the topological order of the dependency tree, including any static analogues of
3606// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3607// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003608func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3609 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003610 var staticPaths android.Paths
3611 for _, staticDep := range staticDeps {
3612 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3613 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3614 }
3615 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003616 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3617 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003618 }
3619 }
3620 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3621
3622 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3623
3624 // reorder the dependencies based on transitive dependencies
3625 staticPaths = android.FirstUniquePaths(staticPaths)
3626 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3627
3628 if len(orderedStaticPaths) != len(staticPaths) {
3629 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3630 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3631 }
3632
3633 return orderedStaticPaths, transitiveStaticLibs
3634}
3635
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003636// BaseLibName trims known prefixes and suffixes
3637func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003638 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3639 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003640 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003641 return libName
3642}
3643
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003644func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003645 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003646 ccDepModule, _ := ccDep.(*Module)
3647 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003648 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003649
Justin Yuncbca3732021-02-03 19:24:13 +09003650 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003651 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003652 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003653 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003654
Ivan Lozanod1dec542021-05-26 15:33:11 -04003655 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003656 }
3657 }
3658
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003659 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3660 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003661 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3662 // core module instead.
3663 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003664 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003665 // The vendor and product modules in Make will have been renamed to not conflict with the
3666 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003667 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003668 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003669 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003670 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003671 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003672 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003673 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003674 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003675 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003676 } else {
3677 return libName
3678 }
3679}
3680
Colin Crossca860ac2016-01-04 14:34:37 -08003681func (c *Module) InstallInData() bool {
3682 if c.installer == nil {
3683 return false
3684 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003685 return c.installer.inData()
3686}
3687
3688func (c *Module) InstallInSanitizerDir() bool {
3689 if c.installer == nil {
3690 return false
3691 }
3692 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003693 return true
3694 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003695 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003696}
3697
Yifan Hong1b3348d2020-01-21 15:53:22 -08003698func (c *Module) InstallInRamdisk() bool {
3699 return c.InRamdisk()
3700}
3701
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003702func (c *Module) InstallInVendorRamdisk() bool {
3703 return c.InVendorRamdisk()
3704}
3705
Jiyong Parkf9332f12018-02-01 00:54:12 +09003706func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003707 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003708}
3709
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003710func (c *Module) MakeUninstallable() {
3711 if c.installer == nil {
3712 c.ModuleBase.MakeUninstallable()
3713 return
3714 }
3715 c.installer.makeUninstallable(c)
3716}
3717
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003718func (c *Module) HostToolPath() android.OptionalPath {
3719 if c.installer == nil {
3720 return android.OptionalPath{}
3721 }
3722 return c.installer.hostToolPath()
3723}
3724
Nan Zhangd4e641b2017-07-12 12:55:28 -07003725func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3726 return c.outputFile
3727}
3728
Colin Cross41955e82019-05-29 14:40:35 -07003729func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3730 switch tag {
3731 case "":
3732 if c.outputFile.Valid() {
3733 return android.Paths{c.outputFile.Path()}, nil
3734 }
3735 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003736 case "unstripped":
3737 if c.linker != nil {
3738 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3739 }
3740 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003741 default:
3742 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003743 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003744}
3745
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003746func (c *Module) static() bool {
3747 if static, ok := c.linker.(interface {
3748 static() bool
3749 }); ok {
3750 return static.static()
3751 }
3752 return false
3753}
3754
Jiyong Park379de2f2018-12-19 02:47:14 +09003755func (c *Module) staticBinary() bool {
3756 if static, ok := c.linker.(interface {
3757 staticBinary() bool
3758 }); ok {
3759 return static.staticBinary()
3760 }
3761 return false
3762}
3763
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003764func (c *Module) testBinary() bool {
3765 if test, ok := c.linker.(interface {
3766 testBinary() bool
3767 }); ok {
3768 return test.testBinary()
3769 }
3770 return false
3771}
3772
Jingwen Chen537242c2022-08-24 11:53:27 +00003773func (c *Module) testLibrary() bool {
3774 if test, ok := c.linker.(interface {
3775 testLibrary() bool
3776 }); ok {
3777 return test.testLibrary()
3778 }
3779 return false
3780}
3781
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003782func (c *Module) benchmarkBinary() bool {
3783 if b, ok := c.linker.(interface {
3784 benchmarkBinary() bool
3785 }); ok {
3786 return b.benchmarkBinary()
3787 }
3788 return false
3789}
3790
3791func (c *Module) fuzzBinary() bool {
3792 if f, ok := c.linker.(interface {
3793 fuzzBinary() bool
3794 }); ok {
3795 return f.fuzzBinary()
3796 }
3797 return false
3798}
3799
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003800// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3801func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003802 if h, ok := c.linker.(interface {
3803 header() bool
3804 }); ok {
3805 return h.header()
3806 }
3807 return false
3808}
3809
Ivan Lozanod7586b62021-04-01 09:49:36 -04003810func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003811 if b, ok := c.linker.(interface {
3812 binary() bool
3813 }); ok {
3814 return b.binary()
3815 }
3816 return false
3817}
3818
Justin Yun5e035862021-06-29 20:50:37 +09003819func (c *Module) StaticExecutable() bool {
3820 if b, ok := c.linker.(*binaryDecorator); ok {
3821 return b.static()
3822 }
3823 return false
3824}
3825
Ivan Lozanod7586b62021-04-01 09:49:36 -04003826func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003827 if o, ok := c.linker.(interface {
3828 object() bool
3829 }); ok {
3830 return o.object()
3831 }
3832 return false
3833}
3834
Ivan Lozanof9e21722020-12-02 09:00:51 -05003835func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003836 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003837 if c.IsLlndk() {
3838 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003839 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003840 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003841 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003842 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003843 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003844 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003845 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003846 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003847 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003848 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003849 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003850 return "native:product"
3851 }
Jooyung Han38002912019-05-16 04:01:54 +09003852 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003853 } else if c.InRamdisk() {
3854 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003855 } else if c.InVendorRamdisk() {
3856 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003857 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003858 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003859 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003860 return "native:ndk:none:none"
3861 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3862 //family, link := getNdkStlFamilyAndLinkType(c)
3863 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003864 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003865 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003866 } else {
3867 return "native:platform"
3868 }
3869}
3870
Jiyong Park9d452992018-10-03 00:38:19 +09003871// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003872// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003873func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003874 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003875 // Stub libs and prebuilt libs in a versioned SDK are not
3876 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003877 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003878 } else if _, ok := c.linker.(testPerSrc); ok {
3879 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003880 }
3881 return false
3882}
3883
Jiyong Parka90ca002019-10-07 15:47:24 +09003884func (c *Module) AvailableFor(what string) bool {
3885 if linker, ok := c.linker.(interface {
3886 availableFor(string) bool
3887 }); ok {
3888 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3889 } else {
3890 return c.ApexModuleBase.AvailableFor(what)
3891 }
3892}
3893
Jiyong Park62304bb2020-04-13 16:19:48 +09003894func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003895 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003896}
3897
Paul Duffin0cb37b92020-03-04 14:52:46 +00003898func (c *Module) EverInstallable() bool {
3899 return c.installer != nil &&
3900 // Check to see whether the module is actually ever installable.
3901 c.installer.everInstallable()
3902}
3903
Ivan Lozanod7586b62021-04-01 09:49:36 -04003904func (c *Module) PreventInstall() bool {
3905 return c.Properties.PreventInstall
3906}
3907
3908func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003909 if c.library != nil {
3910 if i := c.library.installable(); i != nil {
3911 return i
3912 }
3913 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003914 return c.Properties.Installable
3915}
3916
3917func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003918 ret := c.EverInstallable() &&
3919 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003920 proptools.BoolDefault(c.Installable(), true) &&
3921 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003922
3923 // The platform variant doesn't need further condition. Apex variants however might not
3924 // be installable because it will likely to be included in the APEX and won't appear
3925 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003926 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003927 return ret
3928 }
3929
3930 // Special case for modules that are configured to be installed to /data, which includes
3931 // test modules. For these modules, both APEX and non-APEX variants are considered as
3932 // installable. This is because even the APEX variants won't be included in the APEX, but
3933 // will anyway be installed to /data/*.
3934 // See b/146995717
3935 if c.InstallInData() {
3936 return ret
3937 }
3938
3939 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003940}
3941
Logan Chien41eabe62019-04-10 13:33:58 +08003942func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3943 if c.linker != nil {
3944 if library, ok := c.linker.(*libraryDecorator); ok {
3945 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3946 }
3947 }
3948}
3949
Jiyong Park45bf82e2020-12-15 22:29:02 +09003950var _ android.ApexModule = (*Module)(nil)
3951
3952// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003953func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003954 depTag := ctx.OtherModuleDependencyTag(dep)
3955 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3956
3957 if cc, ok := dep.(*Module); ok {
3958 if cc.HasStubsVariants() {
3959 if isLibDepTag && libDepTag.shared() {
3960 // dynamic dep to a stubs lib crosses APEX boundary
3961 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003962 }
Colin Cross6e511a92020-07-27 21:26:48 -07003963 if IsRuntimeDepTag(depTag) {
3964 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003965 return false
3966 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003967 }
Zhijun Heec285872021-04-24 10:47:08 -07003968 if cc.IsLlndk() {
3969 return false
3970 }
Colin Crossaac32222020-07-29 12:51:56 -07003971 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003972 // shared_lib dependency from a static lib is considered as crossing
3973 // the APEX boundary because the dependency doesn't actually is
3974 // linked; the dependency is used only during the compilation phase.
3975 return false
3976 }
Jiyong Parke3867542020-12-03 17:28:25 +09003977
3978 if isLibDepTag && libDepTag.excludeInApex {
3979 return false
3980 }
Colin Cross6e511a92020-07-27 21:26:48 -07003981 }
Colin Crossc1b36442021-05-06 13:42:48 -07003982 if depTag == stubImplDepTag {
3983 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003984 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003985 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003986 if depTag == staticVariantTag {
3987 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3988 // actually mean that the static lib (and its dependencies) are copied into the
3989 // APEX.
3990 return false
3991 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003992 return true
3993}
3994
Jiyong Park45bf82e2020-12-15 22:29:02 +09003995// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003996func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3997 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003998 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3999 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
4000 return nil
4001 }
Jooyung Han749dc692020-04-15 11:03:39 +09004002 // We don't check for prebuilt modules
4003 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
4004 return nil
4005 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09004006
Jooyung Han749dc692020-04-15 11:03:39 +09004007 minSdkVersion := c.MinSdkVersion()
4008 if minSdkVersion == "apex_inherit" {
4009 return nil
4010 }
4011 if minSdkVersion == "" {
4012 // JNI libs within APK-in-APEX fall into here
4013 // Those are okay to set sdk_version instead
4014 // We don't have to check if this is a SDK variant because
4015 // non-SDK variant resets sdk_version, which works too.
4016 minSdkVersion = c.SdkVersion()
4017 }
Dan Albertc8060532020-07-22 22:32:17 -07004018 if minSdkVersion == "" {
4019 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
4020 }
4021 // Not using nativeApiLevelFromUser because the context here is not
4022 // necessarily a native context.
4023 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09004024 if err != nil {
4025 return err
4026 }
Dan Albertc8060532020-07-22 22:32:17 -07004027
Colin Cross8ca61c12022-10-06 21:00:14 -07004028 // A dependency only needs to support a min_sdk_version at least
4029 // as high as the api level that the architecture was introduced in.
4030 // This allows introducing new architectures in the platform that
4031 // need to be included in apexes that normally require an older
4032 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08004033 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07004034 if sdkVersion.LessThan(minApiForArch) {
4035 sdkVersion = minApiForArch
4036 }
4037
Dan Albertc8060532020-07-22 22:32:17 -07004038 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09004039 return fmt.Errorf("newer SDK(%v)", ver)
4040 }
4041 return nil
4042}
4043
Paul Duffinb5769c12021-05-12 16:16:51 +01004044// Implements android.ApexModule
4045func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
4046 // stub libraries and native bridge libraries are always available to platform
4047 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
4048}
4049
Jooyung Han91f92032022-02-04 12:36:33 +09004050// Overrides android.ApexModuleBase.UniqueApexVariations
4051func (c *Module) UniqueApexVariations() bool {
4052 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
4053 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
4054 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09004055 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09004056 return c.UseVndk() && c.IsVndk()
4057}
4058
Inseob Kima1888ce2022-10-04 14:42:02 +09004059func (c *Module) overriddenModules() []string {
4060 if o, ok := c.linker.(overridable); ok {
4061 return o.overriddenModules()
4062 }
4063 return nil
4064}
4065
Rob Seymour925aa092021-08-10 20:42:03 +00004066var _ snapshot.RelativeInstallPath = (*Module)(nil)
4067
Liz Kammer35ca77e2021-12-22 15:31:40 -05004068type moduleType int
4069
4070const (
4071 unknownType moduleType = iota
4072 binary
4073 object
4074 fullLibrary
4075 staticLibrary
4076 sharedLibrary
4077 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00004078 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00004079 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05004080)
4081
4082func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00004083 if c.testBinary() {
4084 // testBinary is also a binary, so this comes before the c.Binary()
4085 // conditional. A testBinary has additional implicit dependencies and
4086 // other test-only semantics.
4087 return testBin
4088 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004089 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004090 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004091 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00004092 } else if c.testLibrary() {
4093 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
4094 // will let them add implicit compile deps on gtest, for example.
4095 //
Liz Kammerefc51d92023-04-21 15:11:25 -04004096 // For now, treat them as regular libraries.
4097 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004098 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05004099 static := false
4100 shared := false
4101 if library, ok := c.linker.(*libraryDecorator); ok {
4102 static = library.MutatedProperties.BuildStatic
4103 shared = library.MutatedProperties.BuildShared
4104 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
4105 static = library.MutatedProperties.BuildStatic
4106 shared = library.MutatedProperties.BuildShared
4107 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004108 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004109 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004110 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004111 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004112 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004113 return staticLibrary
4114 }
4115 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00004116 } else if c.isNDKStubLibrary() {
4117 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05004118 }
4119 return unknownType
4120}
4121
4122// ConvertWithBp2build converts Module to Bazel for bp2build.
4123func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
4124 prebuilt := c.IsPrebuilt()
4125 switch c.typ() {
4126 case binary:
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxb12ff592022-09-01 15:04:04 +00004127 if prebuilt {
4128 prebuiltBinaryBp2Build(ctx, c)
4129 } else {
Jingwen Chen537242c2022-08-24 11:53:27 +00004130 binaryBp2build(ctx, c)
4131 }
4132 case testBin:
4133 if !prebuilt {
4134 testBinaryBp2build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004135 }
4136 case object:
Colin Crossc5075e92022-12-05 16:46:39 -08004137 if prebuilt {
4138 prebuiltObjectBp2Build(ctx, c)
4139 } else {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004140 objectBp2Build(ctx, c)
4141 }
4142 case fullLibrary:
4143 if !prebuilt {
4144 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00004145 } else {
4146 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004147 }
4148 case headerLibrary:
4149 libraryHeadersBp2Build(ctx, c)
4150 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05004151 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00004152 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05004153 } else {
4154 sharedOrStaticLibraryBp2Build(ctx, c, true)
4155 }
4156 case sharedLibrary:
4157 if prebuilt {
4158 prebuiltLibrarySharedBp2Build(ctx, c)
4159 } else {
4160 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004161 }
Chris Parsons39a16972023-06-08 14:28:51 +00004162 default:
4163 ctx.MarkBp2buildUnconvertible(bp2build_metrics_proto.UnconvertedReasonType_TYPE_UNSUPPORTED, "")
Spandan Das8b4a5f32022-09-29 00:28:24 +00004164 }
4165}
4166
4167var _ android.ApiProvider = (*Module)(nil)
4168
4169func (c *Module) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
Spandan Das4238c652022-09-09 01:38:47 +00004170 if c.IsPrebuilt() {
4171 return
4172 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00004173 switch c.typ() {
Spandan Das4238c652022-09-09 01:38:47 +00004174 case fullLibrary:
4175 apiContributionBp2Build(ctx, c)
4176 case sharedLibrary:
4177 apiContributionBp2Build(ctx, c)
4178 case headerLibrary:
4179 // Aggressively generate api targets for all header modules
4180 // This is necessary since the header module does not know if it is a dep of API surface stub library
4181 apiLibraryHeadersBp2Build(ctx, c)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004182 }
4183}
4184
Colin Crosscfad1192015-11-02 16:43:11 -08004185// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004186type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004187 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004188 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004189 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08004190}
4191
Patrice Arrudac249c712019-03-19 17:00:29 -07004192// cc_defaults provides a set of properties that can be inherited by other cc
4193// modules. A module can use the properties from a cc_defaults using
4194// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4195// merged (when possible) by prepending the default module's values to the
4196// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004197func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004198 return DefaultsFactory()
4199}
4200
Colin Cross36242852017-06-23 15:06:31 -07004201func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004202 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004203
Colin Cross36242852017-06-23 15:06:31 -07004204 module.AddProperties(props...)
4205 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004206 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004207 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004208 &BaseCompilerProperties{},
4209 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004210 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004211 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004212 &StaticProperties{},
4213 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004214 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004215 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004216 &TestLinkerProperties{},
4217 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004218 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004219 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004220 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004221 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004222 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004223 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004224 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004225 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004226 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004227 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004228 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004229 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004230 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07004231 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004232 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004233 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4234 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004235 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004236 )
Colin Crosscfad1192015-11-02 16:43:11 -08004237
Jooyung Hancc372c52019-09-25 15:18:44 +09004238 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004239
4240 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004241}
4242
Jiyong Park2286afd2020-06-16 21:58:53 +09004243func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004244 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004245}
4246
Kiyoung Kim51279d32022-08-24 14:10:46 +09004247func (c *Module) isImportedApiLibrary() bool {
4248 _, ok := c.linker.(*apiLibraryDecorator)
4249 return ok
4250}
4251
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004252func kytheExtractAllFactory() android.Singleton {
4253 return &kytheExtractAllSingleton{}
4254}
4255
4256type kytheExtractAllSingleton struct {
4257}
4258
4259func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4260 var xrefTargets android.Paths
4261 ctx.VisitAllModules(func(module android.Module) {
4262 if ccModule, ok := module.(xref); ok {
4263 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4264 }
4265 })
4266 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4267 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004268 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004269 }
4270}
4271
Jihoon Kangf78a8902022-09-01 22:47:07 +00004272func (c *Module) Partition() string {
4273 if p, ok := c.installer.(interface {
4274 getPartition() string
4275 }); ok {
4276 return p.getPartition()
4277 }
4278 return ""
4279}
4280
Colin Cross06a931b2015-10-28 17:23:31 -07004281var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004282var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004283var BoolPtr = proptools.BoolPtr
4284var String = proptools.String
4285var StringPtr = proptools.StringPtr