blob: 1a9c7bf66772460a212d903ddb17cd2b9e764330 [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
Aditya Choudhary87b2ab22023-11-17 15:27:06 +000027 "android/soong/testing"
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +090028
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"
Colin Crossb98c8b02016-07-29 13:44:28 -070034 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070035 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070036 "android/soong/genrule"
Kiyoung Kim487689e2022-07-26 09:48:22 +090037 "android/soong/multitree"
Rob Seymour925aa092021-08-10 20:42:03 +000038 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080039)
40
Colin Cross463a90e2015-06-17 14:20:06 -070041func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000042 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070043
Inseob Kim3b244062023-07-11 13:31:36 +090044 pctx.Import("android/soong/android")
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
Colin Crossf5f4ad32024-01-19 15:41:48 -080071 ctx.Transition("coverage", &coverageTransitionMutator{})
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
Colin Cross33e0c812024-01-23 16:36:07 -080076 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000077
Colin Cross6ac83a82024-01-23 11:23:10 -080078 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +090079
Jooyung Han479ca172020-10-19 18:51:07 +090080 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090081 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070082 })
Colin Crossb98c8b02016-07-29 13:44:28 -070083
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080084 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
85 // sabi mutator needs to be run after apex mutator finishes.
86 ctx.TopDown("sabi_deps", sabiDepsMutator)
87 })
88
LaMont Jones0c10e4d2023-05-16 00:58:37 +000089 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070090}
91
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050092// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
93// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
94// edges to these modules.
95// This object is constructed in DepsMutator, by calling to various module delegates to set
96// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
97// dependencies.
98// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
99// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -0800100type Deps struct {
101 SharedLibs, LateSharedLibs []string
102 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800103 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800104 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700105
Colin Cross3e5e7782022-06-17 22:17:05 +0000106 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
107 // prevent automatically exporting symbols.
108 UnexportedStaticLibs []string
109
Chris Parsons79d66a52020-06-05 17:26:16 -0400110 // Used for data dependencies adjacent to tests
111 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700112 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400113
Yo Chiang219968c2020-09-22 18:45:04 +0800114 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
115 SystemSharedLibs []string
116
Vinh Tran367d89d2023-04-28 11:21:25 -0400117 // Used by DepMutator to pass aidl_library modules to aidl compiler
118 AidlLibs []string
119
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500120 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800121 StaticUnwinderIfLegacy bool
122
Colin Cross5950f382016-12-13 12:50:57 -0800123 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700124
Colin Cross81413472016-04-11 14:37:39 -0700125 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700126
Dan Willemsenb40aab62016-04-20 14:21:14 -0700127 GeneratedSources []string
128 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900129 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700130
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700131 ReexportGeneratedHeaders []string
132
Colin Crossc465efd2021-06-11 18:00:04 -0700133 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700134
135 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700136 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900137
138 // List of libs that need to be excluded for APEX variant
139 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900140 // List of libs that need to be excluded for non-APEX variant
141 ExcludeLibsForNonApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700142}
143
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500144// PathDeps is a struct containing file paths to dependencies of a module.
145// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
146// It's used to construct flags for various build statements (such as for compiling and linking).
147// It is then passed to module decorator functions responsible for registering build statements
148// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800149type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700150 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900151 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700152 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900153 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700154 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700155 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700156
Colin Cross0de8a1e2020-09-18 14:15:30 -0700157 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossc85750b2022-04-21 12:50:51 -0700158 TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700159
Colin Cross26c34ed2016-09-30 17:10:16 -0700160 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100161 Objs Objects
162 // Paths to .o files in dependencies that provide them. Note that these lists
163 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800164 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700165 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700166
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100167 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
168 // the libs from all whole_static_lib dependencies.
169 WholeStaticLibsFromPrebuilts android.Paths
170
Colin Cross26c34ed2016-09-30 17:10:16 -0700171 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700172 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900173 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700174
Inseob Kimd110f872019-12-06 13:15:38 +0900175 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000176 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900177 IncludeDirs android.Paths
178 SystemIncludeDirs android.Paths
179 ReexportedDirs android.Paths
180 ReexportedSystemDirs android.Paths
181 ReexportedFlags []string
182 ReexportedGeneratedHeaders android.Paths
183 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700184
Colin Cross26c34ed2016-09-30 17:10:16 -0700185 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700186 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700187
Dan Willemsena0790e32018-10-12 00:24:23 -0700188 // Path to the dynamic linker binary
189 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700190
191 // For Darwin builds, the path to the second architecture's output that should
192 // be combined with this architectures's output into a FAT MachO file.
193 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400194
195 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
196 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700197}
198
Colin Cross4af21ed2019-11-04 09:37:55 -0800199// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
200// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
201// command line so they can be overridden by the local module flags).
202type LocalOrGlobalFlags struct {
203 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700204 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800205 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700206 CFlags []string // Flags that apply to C and C++ source files
207 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
208 ConlyFlags []string // Flags that apply to C source files
209 CppFlags []string // Flags that apply to C++ source files
210 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700211 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800212}
213
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500214// Flags contains various types of command line flags (and settings) for use in building build
215// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800216type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500217 // Local flags (which individual modules are responsible for). These may override global flags.
218 Local LocalOrGlobalFlags
219 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800220 Global LocalOrGlobalFlags
221
222 aidlFlags []string // Flags that apply to aidl source files
223 rsFlags []string // Flags that apply to renderscript source files
224 libFlags []string // Flags to add libraries early to the link order
225 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
226 TidyFlags []string // Flags that apply to clang-tidy
227 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700228
Colin Crossc3199482017-03-30 15:03:04 -0700229 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800230 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700231 SystemIncludeFlags []string
232
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800233 Toolchain config.Toolchain
234 Tidy bool // True if ninja .tidy rules should be generated.
235 NeedTidyFiles bool // True if module link should depend on .tidy files
236 GcovCoverage bool // True if coverage files should be generated.
237 SAbiDump bool // True if header abi dumps should be generated.
238 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800239
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500240 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800241 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500242 // The target-device system path to the dynamic linker.
243 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800244
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700245 CFlagsDeps android.Paths // Files depended on by compiler flags
246 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800247
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500248 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700249 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800250
Colin Cross19878da2019-03-28 14:45:07 -0700251 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700252 protoC bool // Whether to use C instead of C++
253 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700254
255 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200256 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700257}
258
Colin Crossca860ac2016-01-04 14:34:37 -0800259// Properties used to compile all C or C++ modules
260type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700261 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800262 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700263
Jiyong Parkb35a8192020-08-10 15:59:36 +0900264 // The API level that this module is built against. The APIs of this API level will be
265 // visible at build time, but use of any APIs newer than min_sdk_version will render the
266 // module unloadable on older devices. In the future it will be possible to weakly-link new
267 // APIs, making the behavior match Java: such modules will load on older devices, but
268 // calling new APIs on devices that do not support them will result in a crash.
269 //
270 // This property has the same behavior as sdk_version does for Java modules. For those
271 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
272 // does for Java code.
273 //
274 // In addition, setting this property causes two variants to be built, one for the platform
275 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800276 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700277
Jiyong Parkb35a8192020-08-10 15:59:36 +0900278 // Minimum OS API level supported by this C or C++ module. This property becomes the value
279 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
280 // this property is also used to ensure that the min_sdk_version of the containing module is
281 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
282 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
283 // min_sdk_version of the containing APEX. When the module
284 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900285 Min_sdk_version *string
286
Colin Crossc511bc52020-04-07 16:50:32 +0000287 // If true, always create an sdk variant and don't create a platform variant.
288 Sdk_variant_only *bool
289
Jiyong Parkde866cb2018-12-07 23:08:36 +0900290 AndroidMkSharedLibs []string `blueprint:"mutated"`
291 AndroidMkStaticLibs []string `blueprint:"mutated"`
292 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
293 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700294 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900295 HideFromMake bool `blueprint:"mutated"`
296 PreventInstall bool `blueprint:"mutated"`
297 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700298
Yo Chiang219968c2020-09-22 18:45:04 +0800299 // Set by DepsMutator.
300 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
301
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900302 // The name of the image this module is built for
303 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200304
305 // The VNDK version this module is built against. If empty, the module is not
306 // build against the VNDK.
307 VndkVersion string `blueprint:"mutated"`
308
309 // Suffix for the name of Android.mk entries generated by this module
310 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800311
312 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
313 // file
314 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900315
Yifan Hong39143a92020-10-26 12:43:12 -0700316 // Make this module available when building for ramdisk.
317 // On device without a dedicated recovery partition, the module is only
318 // available after switching root into
319 // /first_stage_ramdisk. To expose the module before switching root, install
320 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800321 Ramdisk_available *bool
322
Yifan Hong39143a92020-10-26 12:43:12 -0700323 // Make this module available when building for vendor ramdisk.
324 // On device without a dedicated recovery partition, the module is only
325 // available after switching root into
326 // /first_stage_ramdisk. To expose the module before switching root, install
327 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700328 Vendor_ramdisk_available *bool
329
Jiyong Parkf9332f12018-02-01 00:54:12 +0900330 // Make this module available when building for recovery
331 Recovery_available *bool
332
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200333 // Used by imageMutator, set by ImageMutatorBegin()
334 CoreVariantNeeded bool `blueprint:"mutated"`
335 RamdiskVariantNeeded bool `blueprint:"mutated"`
336 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
337 RecoveryVariantNeeded bool `blueprint:"mutated"`
338
339 // A list of variations for the "image" mutator of the form
340 //<image name> '.' <version char>, for example, 'vendor.S'
341 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900342
343 // Allows this module to use non-APEX version of libraries. Useful
344 // for building binaries that are started before APEXes are activated.
345 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900346
347 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
348 // see soong/cc/config/vndk.go
349 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900350
351 // Used by vendor snapshot to record dependencies from snapshot modules.
352 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900353 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900354 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000355
Colin Cross1bc94122021-10-28 13:25:54 -0700356 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000357
358 // Set by factories of module types that can only be referenced from variants compiled against
359 // the SDK.
360 AlwaysSdk bool `blueprint:"mutated"`
361
362 // Variant is an SDK variant created by sdkMutator
363 IsSdkVariant bool `blueprint:"mutated"`
364 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
365 // variant to have a ".sdk" suffix.
366 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700367
368 // Normally Soong uses the directory structure to decide which modules
369 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800370 // different snapshots (vendor, recovery, etc.), but this property
371 // allows a partner to exclude a module normally thought of as a
372 // framework module from the vendor snapshot.
373 Exclude_from_vendor_snapshot *bool
374
375 // Normally Soong uses the directory structure to decide which modules
376 // should be included (framework) or excluded (non-framework) from the
377 // different snapshots (vendor, recovery, etc.), but this property
378 // allows a partner to exclude a module normally thought of as a
379 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800380 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900381
382 // List of APEXes that this module has private access to for testing purpose. The module
383 // can depend on libraries that are not exported by the APEXes and use private symbols
384 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000385 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800386
387 Target struct {
388 Platform struct {
389 // List of modules required by the core variant.
390 Required []string `android:"arch_variant"`
391
392 // List of modules not required by the core variant.
393 Exclude_required []string `android:"arch_variant"`
394 } `android:"arch_variant"`
395
396 Recovery struct {
397 // List of modules required by the recovery variant.
398 Required []string `android:"arch_variant"`
399
400 // List of modules not required by the recovery variant.
401 Exclude_required []string `android:"arch_variant"`
402 } `android:"arch_variant"`
403 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700404}
405
406type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900407 // whether this module should be allowed to be directly depended by other
408 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900409 // If set to true, two variants will be built separately, one like
410 // normal, and the other limited to the set of libraries and headers
411 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700412 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900413 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700414 // so it shouldn't have any unversioned runtime dependencies, or
415 // make assumptions about the system that may not be true in the
416 // future.
417 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900418 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900419 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900420 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900421 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900422 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700423 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
424 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900425
Justin Yunebcf0c52021-01-08 18:00:19 +0900426 // This is the same as the "vendor_available" except that the install path
427 // of the vendor variant is /odm or /vendor/odm.
428 // By replacing "vendor_available: true" with "odm_available: true", the
429 // module will install its vendor variant to the /odm partition or /vendor/odm.
430 // As the modules with "odm_available: true" still create the vendor variants,
431 // they can link to the other vendor modules as the vendor_available modules do.
432 // Also, the vendor modules can link to odm_available modules.
433 //
434 // It may not be used for VNDK modules.
435 Odm_available *bool
436
Justin Yun63e9ec72020-10-29 16:49:43 +0900437 // whether this module should be allowed to be directly depended by other
438 // modules with `product_specific: true` or `product_available: true`.
439 // If set to true, an additional product variant will be built separately
440 // that is limited to the set of libraries and headers that are exposed to
441 // /product modules.
442 //
443 // The product variant may be used with a different (newer) /system,
444 // so it shouldn't have any unversioned runtime dependencies, or
445 // make assumptions about the system that may not be true in the
446 // future.
447 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900448 // If set to false, this module becomes inaccessible from /product modules.
449 //
450 // Different from the 'vendor_available' property, the modules with
451 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
452 // library without 'product_available' may not be depended on by any other
453 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900454 //
455 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
456 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
457 Product_available *bool
458
Jiyong Park5fb8c102018-04-09 12:03:06 +0900459 // whether this module is capable of being loaded with other instance
460 // (possibly an older version) of the same module in the same process.
461 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
462 // can be double loaded in a vendor process if the library is also a
463 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
464 // explicitly marked as `double_loadable: true` by the owner, or the dependency
465 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
466 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800467
468 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
469 IsLLNDK bool `blueprint:"mutated"`
470
Colin Cross78212242021-01-06 14:51:30 -0800471 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
472 // set and the module is not listed in VndkMustUseVendorVariantList.
473 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
474
475 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
476 IsVNDKCore bool `blueprint:"mutated"`
477
478 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
479 IsVNDKSP bool `blueprint:"mutated"`
480
481 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
482 // module sets the llndk.private property.
483 IsVNDKPrivate bool `blueprint:"mutated"`
484
485 // IsVNDKProduct is set if a VNDK module sets the product_available property.
486 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700487
488 // IsVendorPublicLibrary is set for the core and product variants of a library that has
489 // vendor_public_library stubs.
490 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800491}
492
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500493// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
494// to understanding details about the type of the current module.
495// For example, one might call these functions to determine whether the current module is a static
496// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800497type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800498 static() bool
499 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700500 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800501 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900502 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900503 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900504 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700505 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900506 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700507 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800508 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900509 minSdkVersion() string
510 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700511 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700512 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800513 IsLlndk() bool
514 IsLlndkPublic() bool
515 isImplementationForLLNDKPublic() bool
516 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900517 isVndk() bool
518 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500519 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700520 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900521 inProduct() bool
522 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800523 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700524 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900525 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900526 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700527 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700528 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800529 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800530 isAfdoCompile() bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000531 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800532 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900533 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800534 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800535 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800536 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700537 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700538 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900539 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800540 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700541 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700542 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800543 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800544 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800545 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800546 notInPlatform() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800547}
548
549type SharedFlags struct {
550 numSharedFlags int
551 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800552}
553
554type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700555 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800556 ModuleContextIntf
557}
558
559type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700560 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800561 ModuleContextIntf
562}
563
Colin Cross37047f12016-12-13 17:06:13 -0800564type DepsContext interface {
565 android.BottomUpMutatorContext
566 ModuleContextIntf
567}
568
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500569// feature represents additional (optional) steps to building cc-related modules, such as invocation
570// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800571type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800572 flags(ctx ModuleContext, flags Flags) Flags
573 props() []interface{}
574}
575
Joe Onorato37f900c2023-07-18 16:58:16 -0700576// Information returned from Generator about the source code it's generating
577type GeneratedSource struct {
578 IncludeDirs android.Paths
579 Sources android.Paths
580 Headers android.Paths
581 ReexportedDirs android.Paths
582}
583
584// generator allows injection of generated code
585type Generator interface {
586 GeneratorProps() []interface{}
587 GeneratorInit(ctx BaseModuleContext)
588 GeneratorDeps(ctx DepsContext, deps Deps) Deps
589 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
590 GeneratorSources(ctx ModuleContext) GeneratedSource
591 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
592}
593
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500594// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500595// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800596type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700597 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800598 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800599 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700600 compilerProps() []interface{}
601
Colin Cross76fada02016-07-27 10:31:13 -0700602 appendCflags([]string)
603 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700604 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800605}
606
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500607// linker is the interface for a linker decorator object. Individual module types can provide
608// their own implementation for this decorator, and thus specify custom logic regarding build
609// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800610type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700611 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800612 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700613 linkerFlags(ctx ModuleContext, flags Flags) Flags
614 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800615 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700616
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700617 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700618 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900619 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800620 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700621
622 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900623 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000624
625 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000626 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800627
628 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000629}
630
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500631// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000632type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500633 sharedLibs []string
634 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
635 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700636 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800637}
638
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500639// installer is the interface for an installer helper object. This helper is responsible for
640// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800641type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700642 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700643 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000644 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800645 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700646 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700647 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900648 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000649 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900650 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800651}
652
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800653type xref interface {
654 XrefCcFiles() android.Paths
655}
656
Inseob Kima1888ce2022-10-04 14:42:02 +0900657type overridable interface {
658 overriddenModules() []string
659}
660
Colin Cross6e511a92020-07-27 21:26:48 -0700661type libraryDependencyKind int
662
663const (
664 headerLibraryDependency = iota
665 sharedLibraryDependency
666 staticLibraryDependency
667)
668
669func (k libraryDependencyKind) String() string {
670 switch k {
671 case headerLibraryDependency:
672 return "headerLibraryDependency"
673 case sharedLibraryDependency:
674 return "sharedLibraryDependency"
675 case staticLibraryDependency:
676 return "staticLibraryDependency"
677 default:
678 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
679 }
680}
681
682type libraryDependencyOrder int
683
684const (
685 earlyLibraryDependency = -1
686 normalLibraryDependency = 0
687 lateLibraryDependency = 1
688)
689
690func (o libraryDependencyOrder) String() string {
691 switch o {
692 case earlyLibraryDependency:
693 return "earlyLibraryDependency"
694 case normalLibraryDependency:
695 return "normalLibraryDependency"
696 case lateLibraryDependency:
697 return "lateLibraryDependency"
698 default:
699 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
700 }
701}
702
703// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
704// tags that have a set of predefined tag objects that are reused for each dependency, a
705// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
706// That means that comparing a libraryDependencyTag for equality will only be equal if all
707// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
708// then check individual metadata fields instead.
709type libraryDependencyTag struct {
710 blueprint.BaseDependencyTag
711
712 // These are exported so that fmt.Printf("%#v") can call their String methods.
713 Kind libraryDependencyKind
714 Order libraryDependencyOrder
715
716 wholeStatic bool
717
718 reexportFlags bool
719 explicitlyVersioned bool
720 dataLib bool
721 ndk bool
722
723 staticUnwinder bool
724
725 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900726
Cindy Zhou18417cb2020-12-10 07:12:38 -0800727 // Whether or not this dependency should skip the apex dependency check
728 skipApexAllowedDependenciesCheck bool
729
Jiyong Parke3867542020-12-03 17:28:25 +0900730 // Whether or not this dependency has to be followed for the apex variants
731 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900732 // Whether or not this dependency has to be followed for the non-apex variants
733 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000734
735 // If true, don't automatically export symbols from the static library into a shared library.
736 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700737}
738
739// header returns true if the libraryDependencyTag is tagging a header lib dependency.
740func (d libraryDependencyTag) header() bool {
741 return d.Kind == headerLibraryDependency
742}
743
744// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
745func (d libraryDependencyTag) shared() bool {
746 return d.Kind == sharedLibraryDependency
747}
748
749// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
750func (d libraryDependencyTag) static() bool {
751 return d.Kind == staticLibraryDependency
752}
753
Colin Cross65cb3142021-12-10 23:05:02 +0000754func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
755 if d.shared() {
756 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
757 }
758 return nil
759}
760
761var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
762
Colin Crosse9fe2942020-11-10 18:12:15 -0800763// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
764// binaries or other shared libraries are installed as dependencies.
765func (d libraryDependencyTag) InstallDepNeeded() bool {
766 return d.shared()
767}
768
769var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
770
771// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700772// libraryDependencyTag. Each tag object is created globally and reused for multiple
773// dependencies (although since the object contains no references, assigning a tag to a
774// variable and modifying it will not modify the original). Users can compare the tag
775// returned by ctx.OtherModuleDependencyTag against the global original
776type dependencyTag struct {
777 blueprint.BaseDependencyTag
778 name string
779}
780
Colin Crosse9fe2942020-11-10 18:12:15 -0800781// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
782// libraryDependencyTag, but where the dependency needs to be installed when the parent is
783// installed.
784type installDependencyTag struct {
785 blueprint.BaseDependencyTag
786 android.InstallAlwaysNeededDependencyTag
787 name string
788}
789
Colin Crossc99deeb2016-04-11 15:06:20 -0700790var (
Colin Cross6e511a92020-07-27 21:26:48 -0700791 genSourceDepTag = dependencyTag{name: "gen source"}
792 genHeaderDepTag = dependencyTag{name: "gen header"}
793 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
794 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900795 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700796 reuseObjTag = dependencyTag{name: "reuse objects"}
797 staticVariantTag = dependencyTag{name: "static variant"}
798 vndkExtDepTag = dependencyTag{name: "vndk extends"}
799 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700800 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800801 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700802 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700803 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000804 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500805 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400806 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700807)
808
Roland Levillainf89cd092019-07-29 16:22:59 +0100809func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700810 ccLibDepTag, ok := depTag.(libraryDependencyTag)
811 return ok && ccLibDepTag.shared()
812}
813
814func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
815 ccLibDepTag, ok := depTag.(libraryDependencyTag)
816 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100817}
818
Zach Johnson3df4e632020-11-06 11:56:27 -0800819func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
820 ccLibDepTag, ok := depTag.(libraryDependencyTag)
821 return ok && ccLibDepTag.header()
822}
823
Roland Levillainf89cd092019-07-29 16:22:59 +0100824func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800825 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100826}
827
828func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700829 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100830 return ok && ccDepTag == testPerSrcDepTag
831}
832
Colin Crossca860ac2016-01-04 14:34:37 -0800833// Module contains the properties and members used by all C/C++ module types, and implements
834// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500835// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
836// interface.
837//
838// To define a C/C++ related module, construct a new Module object and point its delegates to
839// type-specific structs. These delegates will be invoked to register module-specific build
840// statements which may be unique to the module type. For example, module.compiler.compile() should
841// be defined so as to register build statements which are responsible for compiling the module.
842//
843// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
844// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
845// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
846// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800847type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700848 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700849
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700850 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700851 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700852
Colin Crossca860ac2016-01-04 14:34:37 -0800853 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000854 hod android.HostOrDeviceSupported
855 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000856 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700857
Paul Duffina0843f62019-12-13 19:50:38 +0000858 // Allowable SdkMemberTypes of this module type.
859 sdkMemberTypes []android.SdkMemberType
860
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500861 // decorator delegates, initialize before calling Init
862 // these may contain module-specific implementations, and effectively allow for custom
863 // type-specific logic. These members may reference different objects or the same object.
864 // Functions of these decorators will be invoked to initialize and register type-specific
865 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800866 generators []Generator
867 compiler compiler
868 linker linker
869 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500870
Spandan Dase12d2522023-09-12 21:42:31 +0000871 features []feature
872 stl *stl
873 sanitize *sanitize
874 coverage *coverage
875 fuzzer *fuzzer
876 sabi *sabi
877 vndkdep *vndkdep
878 lto *lto
879 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000880 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800881
Colin Cross31076b32020-10-23 17:22:06 -0700882 library libraryInterface
883
Colin Cross635c3b02016-05-18 15:37:25 -0700884 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800885
Colin Crossb98c8b02016-07-29 13:44:28 -0700886 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700887
888 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800889
890 // Flags used to compile this module
891 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700892
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800893 // Shared flags among build rules of this module
894 sharedFlags SharedFlags
895
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800896 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700897 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900898
899 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800900 // Kythe (source file indexer) paths for this compilation module
901 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700902 // Object .o file output paths for this compilation module
903 objFiles android.Paths
904 // Tidy .tidy file output paths for this compilation module
905 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900906
907 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700908 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700909
910 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800911
912 // Aconfig files for all transitive deps. Also exposed via TransitiveDeclarationsInfo
Colin Crossd788b3e2023-11-28 13:14:56 -0800913 mergedAconfigFiles map[string]android.Paths
Colin Crossc472d572015-03-17 15:06:21 -0700914}
915
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200916func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400917 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
918 if b, ok := c.compiler.(*baseCompiler); ok {
919 hasAidl = b.hasSrcExt(".aidl")
920 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
921 hasProto = b.hasSrcExt(".proto")
922 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
923 hasSysprop = b.hasSrcExt(".sysprop")
924 hasWinMsg = b.hasSrcExt(".mc")
925 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
926 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200927 c.AndroidModuleBase().AddJSONData(d)
928 (*d)["Cc"] = map[string]interface{}{
929 "SdkVersion": c.SdkVersion(),
930 "MinSdkVersion": c.MinSdkVersion(),
931 "VndkVersion": c.VndkVersion(),
932 "ProductSpecific": c.ProductSpecific(),
933 "SocSpecific": c.SocSpecific(),
934 "DeviceSpecific": c.DeviceSpecific(),
935 "InProduct": c.InProduct(),
936 "InVendor": c.InVendor(),
937 "InRamdisk": c.InRamdisk(),
938 "InVendorRamdisk": c.InVendorRamdisk(),
939 "InRecovery": c.InRecovery(),
940 "VendorAvailable": c.VendorAvailable(),
941 "ProductAvailable": c.ProductAvailable(),
942 "RamdiskAvailable": c.RamdiskAvailable(),
943 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
944 "RecoveryAvailable": c.RecoveryAvailable(),
945 "OdmAvailable": c.OdmAvailable(),
946 "InstallInData": c.InstallInData(),
947 "InstallInRamdisk": c.InstallInRamdisk(),
948 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
949 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
950 "InstallInRecovery": c.InstallInRecovery(),
951 "InstallInRoot": c.InstallInRoot(),
952 "IsVndk": c.IsVndk(),
953 "IsVndkExt": c.IsVndkExt(),
954 "IsVndkPrivate": c.IsVndkPrivate(),
955 "IsVndkSp": c.IsVndkSp(),
956 "IsLlndk": c.IsLlndk(),
957 "IsLlndkPublic": c.IsLlndkPublic(),
958 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
959 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
960 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
961 "ApexSdkVersion": c.apexSdkVersion,
962 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400963 "AidlSrcs": hasAidl,
964 "LexSrcs": hasLex,
965 "ProtoSrcs": hasProto,
966 "RenderscriptSrcs": hasRenderscript,
967 "SyspropSrcs": hasSysprop,
968 "WinMsgSrcs": hasWinMsg,
969 "YaccSrsc": hasYacc,
970 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200971 }
972}
973
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500974func (c *Module) SetPreventInstall() {
975 c.Properties.PreventInstall = true
976}
977
978func (c *Module) SetHideFromMake() {
979 c.Properties.HideFromMake = true
980}
981
Ivan Lozanod7586b62021-04-01 09:49:36 -0400982func (c *Module) HiddenFromMake() bool {
983 return c.Properties.HideFromMake
984}
985
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800986func (c *Module) RequiredModuleNames() []string {
987 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
988 if c.ImageVariation().Variation == android.CoreVariation {
989 required = append(required, c.Properties.Target.Platform.Required...)
990 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
991 } else if c.InRecovery() {
992 required = append(required, c.Properties.Target.Recovery.Required...)
993 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
994 }
995 return android.FirstUniqueStrings(required)
996}
997
Ivan Lozano52767be2019-10-18 14:49:46 -0700998func (c *Module) Toc() android.OptionalPath {
999 if c.linker != nil {
1000 if library, ok := c.linker.(libraryInterface); ok {
1001 return library.toc()
1002 }
1003 }
1004 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
1005}
1006
1007func (c *Module) ApiLevel() string {
1008 if c.linker != nil {
1009 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001010 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001011 }
1012 }
1013 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1014}
1015
1016func (c *Module) Static() bool {
1017 if c.linker != nil {
1018 if library, ok := c.linker.(libraryInterface); ok {
1019 return library.static()
1020 }
1021 }
1022 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1023}
1024
1025func (c *Module) Shared() bool {
1026 if c.linker != nil {
1027 if library, ok := c.linker.(libraryInterface); ok {
1028 return library.shared()
1029 }
1030 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001031
Ivan Lozano52767be2019-10-18 14:49:46 -07001032 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1033}
1034
1035func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001036 if c.stl != nil {
1037 return c.stl.Properties.SelectedStl
1038 }
1039 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001040}
1041
Ivan Lozano52767be2019-10-18 14:49:46 -07001042func (c *Module) NdkPrebuiltStl() bool {
1043 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1044 return true
1045 }
1046 return false
1047}
1048
1049func (c *Module) StubDecorator() bool {
1050 if _, ok := c.linker.(*stubDecorator); ok {
1051 return true
1052 }
1053 return false
1054}
1055
1056func (c *Module) SdkVersion() string {
1057 return String(c.Properties.Sdk_version)
1058}
1059
Artur Satayev480e25b2020-04-27 18:53:18 +01001060func (c *Module) MinSdkVersion() string {
1061 return String(c.Properties.Min_sdk_version)
1062}
1063
Jiyong Park5df7bd32021-08-25 16:18:46 +09001064func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001065 if linker, ok := c.linker.(*objectLinker); ok {
1066 return linker.isCrt()
1067 }
1068 return false
1069}
1070
Jiyong Park5df7bd32021-08-25 16:18:46 +09001071func (c *Module) SplitPerApiLevel() bool {
1072 return c.canUseSdk() && c.isCrt()
1073}
1074
Colin Crossc511bc52020-04-07 16:50:32 +00001075func (c *Module) AlwaysSdk() bool {
1076 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1077}
1078
Ivan Lozano183a3212019-10-18 14:18:45 -07001079func (c *Module) CcLibrary() bool {
1080 if c.linker != nil {
1081 if _, ok := c.linker.(*libraryDecorator); ok {
1082 return true
1083 }
Colin Crossd48fe732020-09-23 20:37:24 -07001084 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1085 return true
1086 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001087 }
1088 return false
1089}
1090
1091func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001092 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001093 return true
1094 }
1095 return false
1096}
1097
Spandan Dase12d2522023-09-12 21:42:31 +00001098func (c *Module) IsNdkPrebuiltStl() bool {
1099 if c.linker == nil {
1100 return false
1101 }
1102 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1103 return true
1104 }
1105 return false
1106}
1107
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001108func (c *Module) RlibStd() bool {
1109 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1110}
1111
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001112func (c *Module) RustLibraryInterface() bool {
1113 return false
1114}
1115
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001116func (c *Module) IsFuzzModule() bool {
1117 if _, ok := c.compiler.(*fuzzBinary); ok {
1118 return true
1119 }
1120 return false
1121}
1122
1123func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1124 return c.FuzzModule
1125}
1126
1127func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1128 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1129 return fuzzer.fuzzPackagedModule
1130 }
1131 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1132}
1133
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001134func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001135 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1136 return fuzzer.sharedLibraries
1137 }
1138 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1139}
1140
Ivan Lozano2b262972019-11-21 12:30:50 -08001141func (c *Module) NonCcVariants() bool {
1142 return false
1143}
1144
Ivan Lozano183a3212019-10-18 14:18:45 -07001145func (c *Module) SetStatic() {
1146 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001147 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001148 library.setStatic()
1149 return
1150 }
1151 }
1152 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1153}
1154
1155func (c *Module) SetShared() {
1156 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001157 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001158 library.setShared()
1159 return
1160 }
1161 }
1162 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1163}
1164
1165func (c *Module) BuildStaticVariant() bool {
1166 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001167 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001168 return library.buildStatic()
1169 }
1170 }
1171 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1172}
1173
1174func (c *Module) BuildSharedVariant() bool {
1175 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001176 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001177 return library.buildShared()
1178 }
1179 }
1180 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1181}
1182
1183func (c *Module) Module() android.Module {
1184 return c
1185}
1186
Jiyong Parkc20eee32018-09-05 22:36:17 +09001187func (c *Module) OutputFile() android.OptionalPath {
1188 return c.outputFile
1189}
1190
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001191func (c *Module) CoverageFiles() android.Paths {
1192 if c.linker != nil {
1193 if library, ok := c.linker.(libraryInterface); ok {
1194 return library.objs().coverageFiles
1195 }
1196 }
1197 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1198}
1199
Ivan Lozano183a3212019-10-18 14:18:45 -07001200var _ LinkableInterface = (*Module)(nil)
1201
Jiyong Park719b4462019-01-13 00:39:51 +09001202func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001203 if c.linker != nil {
1204 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001205 }
1206 return nil
1207}
1208
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001209func (c *Module) CoverageOutputFile() android.OptionalPath {
1210 if c.linker != nil {
1211 return c.linker.coverageOutputFilePath()
1212 }
1213 return android.OptionalPath{}
1214}
1215
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001216func (c *Module) RelativeInstallPath() string {
1217 if c.installer != nil {
1218 return c.installer.relativeInstallPath()
1219 }
1220 return ""
1221}
1222
Jooyung Han344d5432019-08-23 11:17:39 +09001223func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001224 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001225}
1226
Colin Cross36242852017-06-23 15:06:31 -07001227func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001228 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001229 for _, generator := range c.generators {
1230 c.AddProperties(generator.GeneratorProps()...)
1231 }
Colin Crossca860ac2016-01-04 14:34:37 -08001232 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001233 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001234 }
1235 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001236 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001237 }
1238 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001239 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001240 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001241 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001242 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001243 }
Colin Cross16b23492016-01-06 14:41:07 -08001244 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001245 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001246 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001247 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001248 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001249 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001250 if c.fuzzer != nil {
1251 c.AddProperties(c.fuzzer.props()...)
1252 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001253 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001254 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001255 }
Justin Yun8effde42017-06-23 19:24:43 +09001256 if c.vndkdep != nil {
1257 c.AddProperties(c.vndkdep.props()...)
1258 }
Stephen Craneba090d12017-05-09 15:44:35 -07001259 if c.lto != nil {
1260 c.AddProperties(c.lto.props()...)
1261 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001262 if c.afdo != nil {
1263 c.AddProperties(c.afdo.props()...)
1264 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001265 if c.orderfile != nil {
1266 c.AddProperties(c.orderfile.props()...)
1267 }
Colin Crossca860ac2016-01-04 14:34:37 -08001268 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001269 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001270 }
Colin Crossc472d572015-03-17 15:06:21 -07001271
Colin Cross36242852017-06-23 15:06:31 -07001272 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001273 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001274 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001275
Colin Cross36242852017-06-23 15:06:31 -07001276 return c
Colin Crossc472d572015-03-17 15:06:21 -07001277}
1278
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001279// UseVndk() returns true if this module is built against VNDK.
1280// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001281func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001282 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001283}
1284
Colin Crossc511bc52020-04-07 16:50:32 +00001285func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001286 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001287 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001288}
1289
1290func (c *Module) UseSdk() bool {
1291 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001292 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001293 }
1294 return false
1295}
1296
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001297func (c *Module) isCoverageVariant() bool {
1298 return c.coverage.Properties.IsCoverageVariant
1299}
1300
Colin Cross95f1ca02020-10-29 20:47:22 -07001301func (c *Module) IsNdk(config android.Config) bool {
1302 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001303}
1304
Colin Cross127bb8b2020-12-16 16:46:01 -08001305func (c *Module) IsLlndk() bool {
1306 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001307}
1308
Colin Cross127bb8b2020-12-16 16:46:01 -08001309func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001310 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001311}
1312
Colin Cross1f3f1302021-04-26 18:37:44 -07001313func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001314 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001315 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001316}
1317
Colin Cross5271fea2021-04-27 13:06:04 -07001318func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1319 lib := moduleLibraryInterface(m)
1320 return lib != nil && (lib.hasVendorPublicLibrary())
1321}
1322
1323// IsVendorPublicLibrary returns true for vendor public libraries.
1324func (c *Module) IsVendorPublicLibrary() bool {
1325 return c.VendorProperties.IsVendorPublicLibrary
1326}
1327
Ivan Lozanof1868af2022-04-12 13:08:36 -04001328func (c *Module) IsVndkPrebuiltLibrary() bool {
1329 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1330 return true
1331 }
1332 return false
1333}
1334
1335func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1336 return c.Properties.SdkAndPlatformVariantVisibleToMake
1337}
1338
Ivan Lozanod7586b62021-04-01 09:49:36 -04001339func (c *Module) HasLlndkStubs() bool {
1340 lib := moduleLibraryInterface(c)
1341 return lib != nil && lib.hasLLNDKStubs()
1342}
1343
1344func (c *Module) StubsVersion() string {
1345 if lib, ok := c.linker.(versionedInterface); ok {
1346 return lib.stubsVersion()
1347 }
1348 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1349}
1350
Colin Cross127bb8b2020-12-16 16:46:01 -08001351// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1352// and does not set llndk.vendor_available: false.
1353func (c *Module) isImplementationForLLNDKPublic() bool {
1354 library, _ := c.library.(*libraryDecorator)
1355 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001356 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001357}
1358
Justin Yunfd9e8042020-12-23 18:23:14 +09001359// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001360func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001361 // Check if VNDK-core-private or VNDK-SP-private
1362 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001363 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001364 }
1365
1366 // Check if LLNDK-private
1367 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001368 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001369 }
1370
1371 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001372}
1373
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001374// IsVndk() returns true if this module has a vndk variant.
1375// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1376// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001377func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001378 if vndkdep := c.vndkdep; vndkdep != nil {
1379 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001380 }
1381 return false
1382}
1383
Yi Kong4ef54592022-02-14 20:00:10 +08001384func (c *Module) isAfdoCompile() bool {
1385 if afdo := c.afdo; afdo != nil {
Vinh Tran44cb78c2023-03-09 22:07:19 -05001386 return afdo.Properties.FdoProfilePath != nil
Yi Kong4ef54592022-02-14 20:00:10 +08001387 }
1388 return false
1389}
1390
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001391func (c *Module) isOrderfileCompile() bool {
1392 if orderfile := c.orderfile; orderfile != nil {
1393 return orderfile.Properties.OrderfileLoad
1394 }
1395 return false
1396}
1397
Yi Kongc702ebd2022-08-19 16:02:45 +08001398func (c *Module) isCfi() bool {
1399 if sanitize := c.sanitize; sanitize != nil {
Yi Kongddffe722023-07-18 16:40:36 +09001400 return Bool(sanitize.Properties.SanitizeMutated.Cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001401 }
1402 return false
1403}
1404
Yi Konged79fa32023-06-04 17:15:42 +09001405func (c *Module) isFuzzer() bool {
1406 if sanitize := c.sanitize; sanitize != nil {
1407 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1408 }
1409 return false
1410}
1411
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001412func (c *Module) isNDKStubLibrary() bool {
1413 if _, ok := c.compiler.(*stubDecorator); ok {
1414 return true
1415 }
1416 return false
1417}
1418
Ivan Lozanod7586b62021-04-01 09:49:36 -04001419func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001420 if vndkdep := c.vndkdep; vndkdep != nil {
1421 return vndkdep.isVndkSp()
1422 }
1423 return false
1424}
1425
Ivan Lozanof9e21722020-12-02 09:00:51 -05001426func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001427 if vndkdep := c.vndkdep; vndkdep != nil {
1428 return vndkdep.isVndkExt()
1429 }
1430 return false
1431}
1432
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001433func (c *Module) SubName() string {
1434 return c.Properties.SubName
1435}
1436
Ivan Lozano52767be2019-10-18 14:49:46 -07001437func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001438 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001439}
1440
Logan Chienf3511742017-10-31 18:04:35 +08001441func (c *Module) getVndkExtendsModuleName() string {
1442 if vndkdep := c.vndkdep; vndkdep != nil {
1443 return vndkdep.getVndkExtendsModuleName()
1444 }
1445 return ""
1446}
1447
Jiyong Park25fc6a92018-11-18 18:02:45 +09001448func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001449 if lib := c.library; lib != nil {
1450 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001451 }
1452 return false
1453}
1454
1455func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001456 if lib := c.library; lib != nil {
1457 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001458 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001459 return false
1460}
1461
Alan Stokes73feba32022-11-14 12:21:24 +00001462func (c *Module) IsStubsImplementationRequired() bool {
1463 if lib := c.library; lib != nil {
1464 return lib.isStubsImplementationRequired()
1465 }
1466 return false
1467}
1468
Colin Cross0477b422020-10-13 18:43:54 -07001469// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1470// the implementation. If it is an implementation library it returns its own name.
1471func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1472 name := ctx.OtherModuleName(c)
1473 if versioned, ok := c.linker.(versionedInterface); ok {
1474 name = versioned.implementationModuleName(name)
1475 }
1476 return name
1477}
1478
Martin Stjernholm2856c662020-12-02 15:03:42 +00001479// Similar to ImplementationModuleName, but uses the Make variant of the module
1480// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1481// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1482// under the premise that the prebuilt module overrides its source counterpart
1483// if it is exposed to Make).
1484func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1485 name := c.BaseModuleName()
1486 if versioned, ok := c.linker.(versionedInterface); ok {
1487 name = versioned.implementationModuleName(name)
1488 }
1489 return name
1490}
1491
Jiyong Park7d55b612021-06-11 17:22:09 +09001492func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001493 return Bool(c.Properties.Bootstrap)
1494}
1495
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001496func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001497 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1498 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1499 return false
1500 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001501 return c.linker != nil && c.linker.nativeCoverage()
1502}
1503
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001504func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001505 if p, ok := c.linker.(SnapshotInterface); ok {
1506 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001507 }
1508 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001509}
1510
Bill Peckham945441c2020-08-31 16:07:58 -07001511func (c *Module) ExcludeFromVendorSnapshot() bool {
1512 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1513}
1514
Jose Galmesf7294582020-11-13 12:07:36 -08001515func (c *Module) ExcludeFromRecoverySnapshot() bool {
1516 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1517}
1518
Jiyong Parkf1194352019-02-25 11:05:47 +09001519func isBionic(name string) bool {
1520 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001521 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001522 return true
1523 }
1524 return false
1525}
1526
Martin Stjernholm279de572019-09-10 23:18:20 +01001527func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001528 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001529 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001530 }
1531 return isBionic(name)
1532}
1533
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001534func (c *Module) XrefCcFiles() android.Paths {
1535 return c.kytheFiles
1536}
1537
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001538func (c *Module) isCfiAssemblySupportEnabled() bool {
1539 return c.sanitize != nil &&
1540 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1541}
1542
Inseob Kim800d1142021-06-14 12:03:51 +09001543func (c *Module) InstallInRoot() bool {
1544 return c.installer != nil && c.installer.installInRoot()
1545}
1546
Colin Crossca860ac2016-01-04 14:34:37 -08001547type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001548 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001549 moduleContextImpl
1550}
1551
Colin Cross37047f12016-12-13 17:06:13 -08001552type depsContext struct {
1553 android.BottomUpMutatorContext
1554 moduleContextImpl
1555}
1556
Colin Crossca860ac2016-01-04 14:34:37 -08001557type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001558 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001559 moduleContextImpl
1560}
1561
1562type moduleContextImpl struct {
1563 mod *Module
1564 ctx BaseModuleContext
1565}
1566
Colin Crossb98c8b02016-07-29 13:44:28 -07001567func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001568 return ctx.mod.toolchain(ctx.ctx)
1569}
1570
1571func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001572 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001573}
1574
1575func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001576 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001577}
1578
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001579func (ctx *moduleContextImpl) testBinary() bool {
1580 return ctx.mod.testBinary()
1581}
1582
Yi Kong56fc1b62022-09-06 16:24:00 +08001583func (ctx *moduleContextImpl) testLibrary() bool {
1584 return ctx.mod.testLibrary()
1585}
1586
Jiyong Park1d1119f2019-07-29 21:27:18 +09001587func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001588 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001589}
1590
Inseob Kim7f283f42020-06-01 21:53:49 +09001591func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001592 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001593}
1594
Inseob Kim1042d292020-06-01 23:23:05 +09001595func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001596 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001597}
1598
Jooyung Hanccce2f22020-03-07 03:45:53 +09001599func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001600 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001601}
1602
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001603func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001604 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001605}
1606
1607func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001608 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001609 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001610 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001611 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001612 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001613 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001614 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001615 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001616 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001617 }
1618 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001619}
1620
Jiyong Parkb35a8192020-08-10 15:59:36 +09001621func (ctx *moduleContextImpl) minSdkVersion() string {
1622 ver := ctx.mod.MinSdkVersion()
1623 if ver == "apex_inherit" && !ctx.isForPlatform() {
1624 ver = ctx.apexSdkVersion().String()
1625 }
1626 if ver == "apex_inherit" || ver == "" {
1627 ver = ctx.sdkVersion()
1628 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001629 // For crt objects, the meaning of min_sdk_version is very different from other types of
1630 // module. For them, min_sdk_version defines the oldest version that the build system will
1631 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1632 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1633 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001634 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1635 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1636 // support such an old version. The version is set to the later version in case when the
1637 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1638 // it's for an APEX.
1639 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1640 if ctx.isForPlatform() {
1641 ver = strconv.Itoa(android.FutureApiLevelInt)
1642 } else { // for apex
1643 ver = ctx.apexSdkVersion().String()
1644 if ver == "" { // in case when min_sdk_version was not set by the APEX
1645 ver = ctx.sdkVersion()
1646 }
1647 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001648 }
1649
Jiyong Parkb35a8192020-08-10 15:59:36 +09001650 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1651 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1652 minSdkVersionInt, err2 := strconv.Atoi(ver)
1653 if err == nil && err2 == nil {
1654 if sdkVersionInt < minSdkVersionInt {
1655 return strconv.Itoa(sdkVersionInt)
1656 }
1657 }
1658 return ver
1659}
1660
1661func (ctx *moduleContextImpl) isSdkVariant() bool {
1662 return ctx.mod.IsSdkVariant()
1663}
1664
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001665func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001666 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001667}
Justin Yun8effde42017-06-23 19:24:43 +09001668
Kiyoung Kimaa394802024-01-08 12:55:45 +09001669func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1670 return ctx.mod.InVendorOrProduct()
1671}
1672
Colin Cross95f1ca02020-10-29 20:47:22 -07001673func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1674 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001675}
1676
Colin Cross127bb8b2020-12-16 16:46:01 -08001677func (ctx *moduleContextImpl) IsLlndk() bool {
1678 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001679}
1680
Colin Cross127bb8b2020-12-16 16:46:01 -08001681func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1682 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001683}
1684
Colin Cross127bb8b2020-12-16 16:46:01 -08001685func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1686 return ctx.mod.isImplementationForLLNDKPublic()
1687}
1688
1689func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1690 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001691}
1692
Logan Chienf3511742017-10-31 18:04:35 +08001693func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001694 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001695}
1696
Yi Kong4ef54592022-02-14 20:00:10 +08001697func (ctx *moduleContextImpl) isAfdoCompile() bool {
1698 return ctx.mod.isAfdoCompile()
1699}
1700
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001701func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1702 return ctx.mod.isOrderfileCompile()
1703}
1704
Yi Kongc702ebd2022-08-19 16:02:45 +08001705func (ctx *moduleContextImpl) isCfi() bool {
1706 return ctx.mod.isCfi()
1707}
1708
Yi Konged79fa32023-06-04 17:15:42 +09001709func (ctx *moduleContextImpl) isFuzzer() bool {
1710 return ctx.mod.isFuzzer()
1711}
1712
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001713func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1714 return ctx.mod.isNDKStubLibrary()
1715}
1716
Justin Yun8effde42017-06-23 19:24:43 +09001717func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001718 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001719}
1720
Ivan Lozanof9e21722020-12-02 09:00:51 -05001721func (ctx *moduleContextImpl) IsVndkExt() bool {
1722 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001723}
1724
Colin Cross5271fea2021-04-27 13:06:04 -07001725func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1726 return ctx.mod.IsVendorPublicLibrary()
1727}
1728
Vic Yangefd249e2018-11-12 20:19:56 -08001729func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001730 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001731}
1732
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001733func (ctx *moduleContextImpl) selectedStl() string {
1734 if stl := ctx.mod.stl; stl != nil {
1735 return stl.Properties.SelectedStl
1736 }
1737 return ""
1738}
1739
Ivan Lozanobd721262018-11-27 14:33:03 -08001740func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1741 return ctx.mod.linker.useClangLld(actx)
1742}
1743
Colin Crossce75d2c2016-10-06 16:12:58 -07001744func (ctx *moduleContextImpl) baseModuleName() string {
1745 return ctx.mod.ModuleBase.BaseModuleName()
1746}
1747
Logan Chienf3511742017-10-31 18:04:35 +08001748func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1749 return ctx.mod.getVndkExtendsModuleName()
1750}
1751
Logan Chiene274fc92019-12-03 11:18:32 -08001752func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001753 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1754 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001755}
1756
Colin Crosse07f2312020-08-13 11:24:56 -07001757func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001758 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1759 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001760}
1761
Dan Albertc8060532020-07-22 22:32:17 -07001762func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001763 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001764}
1765
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001766func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001767 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001768}
1769
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001770func (ctx *moduleContextImpl) nativeCoverage() bool {
1771 return ctx.mod.nativeCoverage()
1772}
1773
Colin Cross56a83212020-09-15 18:30:11 -07001774func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1775 return ctx.mod.DirectlyInAnyApex()
1776}
1777
Colin Cross95b07f22020-12-16 11:06:50 -08001778func (ctx *moduleContextImpl) isPreventInstall() bool {
1779 return ctx.mod.Properties.PreventInstall
1780}
1781
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001782func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1783 shared := &ctx.mod.sharedFlags
1784 if shared.flagsMap == nil {
1785 shared.numSharedFlags = 0
1786 shared.flagsMap = make(map[string]string)
1787 }
1788 return shared
1789}
1790
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001791func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1792 return ctx.mod.isCfiAssemblySupportEnabled()
1793}
1794
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001795func (ctx *moduleContextImpl) notInPlatform() bool {
1796 return ctx.mod.NotInPlatform()
1797}
1798
Colin Cross635c3b02016-05-18 15:37:25 -07001799func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001800 return &Module{
1801 hod: hod,
1802 multilib: multilib,
1803 }
1804}
1805
Colin Cross635c3b02016-05-18 15:37:25 -07001806func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001807 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001808 module.features = []feature{
1809 &tidyFeature{},
1810 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001811 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001812 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001813 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001814 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001815 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001816 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001817 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001818 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001819 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001820 return module
1821}
1822
Colin Crossce75d2c2016-10-06 16:12:58 -07001823func (c *Module) Prebuilt() *android.Prebuilt {
1824 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1825 return p.prebuilt()
1826 }
1827 return nil
1828}
1829
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001830func (c *Module) IsPrebuilt() bool {
1831 return c.Prebuilt() != nil
1832}
1833
Colin Crossce75d2c2016-10-06 16:12:58 -07001834func (c *Module) Name() string {
1835 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001836 if p, ok := c.linker.(interface {
1837 Name(string) string
1838 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001839 name = p.Name(name)
1840 }
1841 return name
1842}
1843
Alex Light3d673592019-01-18 14:37:31 -08001844func (c *Module) Symlinks() []string {
1845 if p, ok := c.installer.(interface {
1846 symlinkList() []string
1847 }); ok {
1848 return p.symlinkList()
1849 }
1850 return nil
1851}
1852
Roland Levillainf89cd092019-07-29 16:22:59 +01001853func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1854 test, ok := c.linker.(testPerSrc)
1855 return ok && test.isAllTestsVariation()
1856}
1857
Chris Parsons216e10a2020-07-09 17:12:52 -04001858func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001859 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001860 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001861 }); ok {
1862 return p.dataPaths()
1863 }
1864 return nil
1865}
1866
Ivan Lozanof1868af2022-04-12 13:08:36 -04001867func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001868 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1869 // "current", it will append the VNDK version to the name suffix.
1870 var vndkVersion string
1871 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001872 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001873 if c.ProductSpecific() {
1874 // If the module is product specific with 'product_specific: true',
1875 // do not add a name suffix because it is a base module.
1876 return ""
1877 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001878 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001879 } else {
1880 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001881 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001882 }
1883 if vndkVersion == "current" {
1884 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1885 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001886 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001887 // add version suffix only if the module is using different vndk version than the
1888 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001889 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001890 }
1891 return nameSuffix
1892}
1893
Ivan Lozanof1868af2022-04-12 13:08:36 -04001894func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1895 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001896
1897 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001898 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001899 }
1900
Colin Cross127bb8b2020-12-16 16:46:01 -08001901 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001902 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001903 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1904 // added for product variant only when we have vendor and product variants with core
1905 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001906 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001907 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001908 subName += vendorPublicLibrarySuffix
1909 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001910 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1911 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001912 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001913 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001914 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001915 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001916 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001917 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001918 subName += RecoverySuffix
1919 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1920 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001921 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001922 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001923 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001924 } else if c.IsStubs() && c.IsSdkVariant() {
1925 // Public API surface (NDK)
1926 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1927 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001928 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001929
1930 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001931}
1932
Sam Delmerico75dbca22023-04-20 13:13:25 +00001933func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1934 ctx := &moduleContext{
1935 ModuleContext: actx,
1936 moduleContextImpl: moduleContextImpl{
1937 mod: c,
1938 },
1939 }
1940 ctx.ctx = ctx
1941 return ctx
1942}
1943
Spandan Das20fce2d2023-04-12 17:21:39 +00001944// TODO (b/277651159): Remove this allowlist
1945var (
1946 skipStubLibraryMultipleApexViolation = map[string]bool{
1947 "libclang_rt.asan": true,
1948 "libclang_rt.hwasan": true,
1949 // runtime apex
1950 "libc": true,
1951 "libc_hwasan": true,
1952 "libdl_android": true,
1953 "libm": true,
1954 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001955 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001956 // art apex
1957 "libandroidio": true,
1958 "libdexfile": true,
1959 "libnativebridge": true,
1960 "libnativehelper": true,
1961 "libnativeloader": true,
1962 "libsigchain": true,
1963 }
1964)
1965
1966// Returns true if a stub library could be installed in multiple apexes
1967func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1968 // If this is not an apex variant, no check necessary
1969 if !c.InAnyApex() {
1970 return false
1971 }
1972 // If this is not a stub library, no check necessary
1973 if !c.HasStubsVariants() {
1974 return false
1975 }
1976 // Skip the allowlist
1977 // Use BaseModuleName so that this matches prebuilts.
1978 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1979 return false
1980 }
1981
1982 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1983 // Stub libraries should not have more than one apex_available
1984 if len(aaWithoutTestApexes) > 1 {
1985 return true
1986 }
1987 // Stub libraries should not use the wildcard
1988 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1989 return true
1990 }
1991 // Default: no violation
1992 return false
1993}
1994
LaMont Jonesafe7baf2024-01-09 22:47:39 +00001995func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1996 android.CollectDependencyAconfigFiles(ctx, &d.mergedAconfigFiles)
1997}
1998
Chris Parsons8d6e4332021-02-22 16:13:50 -05001999func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05002000 // Handle the case of a test module split by `test_per_src` mutator.
2001 //
2002 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
2003 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
2004 // module and return early, as this module does not produce an output file per se.
2005 if c.IsTestPerSrcAllTestsVariation() {
2006 c.outputFile = android.OptionalPath{}
2007 return
2008 }
2009
Ivan Lozanof1868af2022-04-12 13:08:36 -04002010 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08002011 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002012 if !apexInfo.IsForPlatform() {
2013 c.hideApexVariantFromMake = true
2014 }
2015
Chris Parsonseefc9e62021-04-02 17:36:47 -04002016 c.makeLinkType = GetMakeLinkType(actx, c)
2017
Sam Delmerico75dbca22023-04-20 13:13:25 +00002018 ctx := moduleContextFromAndroidModuleContext(actx, c)
Colin Crossca860ac2016-01-04 14:34:37 -08002019
Colin Crossf18e1102017-11-16 14:33:08 -08002020 deps := c.depsToPaths(ctx)
2021 if ctx.Failed() {
2022 return
2023 }
2024
Joe Onorato37f900c2023-07-18 16:58:16 -07002025 for _, generator := range c.generators {
2026 gen := generator.GeneratorSources(ctx)
2027 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
2028 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
2029 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
2030 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
2031 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
2032 if len(deps.Objs.objFiles) == 0 {
2033 // If we are reusuing object files (which happens when we're a shared library and we're
2034 // reusing our static variant's object files), then skip adding the actual source files,
2035 // because we already have the object for it.
2036 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
2037 }
2038 }
2039
2040 if ctx.Failed() {
2041 return
2042 }
2043
Spandan Das20fce2d2023-04-12 17:21:39 +00002044 if c.stubLibraryMultipleApexViolation(actx) {
2045 actx.PropertyErrorf("apex_available",
2046 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
2047 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002048 if c.Properties.Clang != nil && *c.Properties.Clang == false {
2049 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00002050 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
2051 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002052 }
2053
Colin Crossca860ac2016-01-04 14:34:37 -08002054 flags := Flags{
2055 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002056 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002057 }
Joe Onorato37f900c2023-07-18 16:58:16 -07002058 for _, generator := range c.generators {
2059 flags = generator.GeneratorFlags(ctx, flags, deps)
2060 }
Colin Crossca860ac2016-01-04 14:34:37 -08002061 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002062 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002063 }
2064 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002065 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002066 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002067 if c.stl != nil {
2068 flags = c.stl.flags(ctx, flags)
2069 }
Colin Cross16b23492016-01-06 14:41:07 -08002070 if c.sanitize != nil {
2071 flags = c.sanitize.flags(ctx, flags)
2072 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002073 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002074 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002075 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002076 if c.fuzzer != nil {
2077 flags = c.fuzzer.flags(ctx, flags)
2078 }
Stephen Craneba090d12017-05-09 15:44:35 -07002079 if c.lto != nil {
2080 flags = c.lto.flags(ctx, flags)
2081 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002082 if c.afdo != nil {
2083 flags = c.afdo.flags(ctx, flags)
2084 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002085 if c.orderfile != nil {
2086 flags = c.orderfile.flags(ctx, flags)
2087 }
Colin Crossca860ac2016-01-04 14:34:37 -08002088 for _, feature := range c.features {
2089 flags = feature.flags(ctx, flags)
2090 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002091 if ctx.Failed() {
2092 return
2093 }
2094
Colin Cross4af21ed2019-11-04 09:37:55 -08002095 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2096 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2097 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002098
Colin Cross4af21ed2019-11-04 09:37:55 -08002099 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002100
2101 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002102 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002103 }
2104 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002105 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002106 }
2107
Colin Cross3e5e7782022-06-17 22:17:05 +00002108 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2109
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002110 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002111 // We need access to all the flags seen by a source file.
2112 if c.sabi != nil {
2113 flags = c.sabi.flags(ctx, flags)
2114 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002115
Colin Cross4af21ed2019-11-04 09:37:55 -08002116 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002117
Joe Onorato37f900c2023-07-18 16:58:16 -07002118 for _, generator := range c.generators {
2119 generator.GeneratorBuildActions(ctx, flags, deps)
2120 }
2121
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002122 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002123 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002124 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002125 if ctx.Failed() {
2126 return
2127 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002128 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002129 c.objFiles = objs.objFiles
2130 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002131 }
2132
Colin Crossca860ac2016-01-04 14:34:37 -08002133 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002134 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002135 if ctx.Failed() {
2136 return
2137 }
Colin Cross635c3b02016-05-18 15:37:25 -07002138 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002139
Chris Parsons94a0bba2021-06-04 15:03:47 -04002140 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002141
Jose Galmes6f843bc2020-12-11 13:36:29 -08002142 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2143 // RECOVERY_SNAPSHOT_VERSION is current.
2144 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002145 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002146 i.collectHeadersForSnapshot(ctx)
2147 }
2148 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002149 }
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002150 if c.testModule {
Colin Cross40213022023-12-13 15:19:49 -08002151 android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{})
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002152 }
Colin Cross40213022023-12-13 15:19:49 -08002153 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002154
LaMont Jonesaa005ae2023-12-19 19:01:57 +00002155 android.CollectDependencyAconfigFiles(ctx, &c.mergedAconfigFiles)
Yu Liueae7b362023-11-16 17:05:47 -08002156
Chris Parsons94a0bba2021-06-04 15:03:47 -04002157 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002158
2159 if c.linker != nil {
2160 moduleInfoJSON := ctx.ModuleInfoJSON()
2161 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2162 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2163 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2164 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2165 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2166
2167 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2168 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2169 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2170 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2171
2172 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2173 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2174 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2175 moduleInfoJSON.SubName += ".cfi"
2176 }
2177 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2178 moduleInfoJSON.SubName += ".hwasan"
2179 }
2180 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2181 moduleInfoJSON.SubName += ".scs"
2182 }
2183 }
2184 moduleInfoJSON.SubName += c.Properties.SubName
2185
2186 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2187 moduleInfoJSON.Uninstallable = true
2188 }
2189
2190 }
Chris Parsons94a0bba2021-06-04 15:03:47 -04002191}
2192
2193func (c *Module) maybeUnhideFromMake() {
2194 // If a lib is directly included in any of the APEXes or is not available to the
2195 // platform (which is often the case when the stub is provided as a prebuilt),
2196 // unhide the stubs variant having the latest version gets visible to make. In
2197 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2198 // force anything in the make world to link against the stubs library. (unless it
2199 // is explicitly referenced via .bootstrap suffix or the module is marked with
2200 // 'bootstrap: true').
2201 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002202 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002203 c.IsStubs() && !c.InVendorRamdisk() {
2204 c.Properties.HideFromMake = false // unhide
2205 // Note: this is still non-installable
2206 }
2207}
2208
Colin Cross8ff10582023-12-07 13:10:56 -08002209// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2210// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002211func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002212 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002213 // If the module has been specifically configure to not be installed then
2214 // hide from make as otherwise it will break when running inside make
2215 // as the output path to install will not be specified. Not all uninstallable
2216 // modules can be hidden from make as some are needed for resolving make side
2217 // dependencies.
2218 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002219 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002220 c.SkipInstall()
2221 }
2222
2223 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2224 // to allow using the outputs in a genrule.
2225 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002226 c.installer.install(ctx, c.outputFile.Path())
2227 if ctx.Failed() {
2228 return
Colin Crossca860ac2016-01-04 14:34:37 -08002229 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002230 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002231}
2232
Colin Cross0ea8ba82019-06-06 14:33:29 -07002233func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002234 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002235 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002236 }
Colin Crossca860ac2016-01-04 14:34:37 -08002237 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002238}
2239
Colin Crossca860ac2016-01-04 14:34:37 -08002240func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002241 for _, generator := range c.generators {
2242 generator.GeneratorInit(ctx)
2243 }
Colin Crossca860ac2016-01-04 14:34:37 -08002244 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002245 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002246 }
Colin Crossca860ac2016-01-04 14:34:37 -08002247 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002248 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002249 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002250 if c.stl != nil {
2251 c.stl.begin(ctx)
2252 }
Colin Cross16b23492016-01-06 14:41:07 -08002253 if c.sanitize != nil {
2254 c.sanitize.begin(ctx)
2255 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002256 if c.coverage != nil {
2257 c.coverage.begin(ctx)
2258 }
Yi Kong9723e332023-12-04 14:52:53 +09002259 if c.afdo != nil {
2260 c.afdo.begin(ctx)
2261 }
Stephen Craneba090d12017-05-09 15:44:35 -07002262 if c.lto != nil {
2263 c.lto.begin(ctx)
2264 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002265 if c.orderfile != nil {
2266 c.orderfile.begin(ctx)
2267 }
Dan Albert92fe7402020-07-15 13:33:30 -07002268 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002269 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002270 if err != nil {
2271 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002272 c.Properties.Sdk_version = nil
2273 } else {
2274 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002275 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002276 }
Colin Crossca860ac2016-01-04 14:34:37 -08002277}
2278
Colin Cross37047f12016-12-13 17:06:13 -08002279func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002280 deps := Deps{}
2281
Joe Onorato37f900c2023-07-18 16:58:16 -07002282 for _, generator := range c.generators {
2283 deps = generator.GeneratorDeps(ctx, deps)
2284 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002285 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002286 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002287 }
2288 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002289 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002290 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002291 if c.stl != nil {
2292 deps = c.stl.deps(ctx, deps)
2293 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002294 if c.coverage != nil {
2295 deps = c.coverage.deps(ctx, deps)
2296 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002297
Colin Crossb6715442017-10-24 11:13:31 -07002298 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2299 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2300 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2301 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2302 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2303 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002304 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002305
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002306 for _, lib := range deps.ReexportSharedLibHeaders {
2307 if !inList(lib, deps.SharedLibs) {
2308 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2309 }
2310 }
2311
2312 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002313 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2314 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 -07002315 }
2316 }
2317
Colin Cross5950f382016-12-13 12:50:57 -08002318 for _, lib := range deps.ReexportHeaderLibHeaders {
2319 if !inList(lib, deps.HeaderLibs) {
2320 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2321 }
2322 }
2323
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002324 for _, gen := range deps.ReexportGeneratedHeaders {
2325 if !inList(gen, deps.GeneratedHeaders) {
2326 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2327 }
2328 }
2329
Colin Crossc99deeb2016-04-11 15:06:20 -07002330 return deps
2331}
2332
Dan Albert7e9d2952016-08-04 13:02:36 -07002333func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002334 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002335 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002336 moduleContextImpl: moduleContextImpl{
2337 mod: c,
2338 },
2339 }
2340 ctx.ctx = ctx
2341
Vinh Tran44cb78c2023-03-09 22:07:19 -05002342 if !actx.Host() || !ctx.static() || ctx.staticBinary() {
2343 c.afdo.addDep(ctx, actx)
2344 }
2345
Colin Crossca860ac2016-01-04 14:34:37 -08002346 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002347}
2348
Jiyong Park7ed9de32018-10-15 22:25:07 +09002349// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002350func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002351 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2352 version := name[sharp+1:]
2353 libname := name[:sharp]
2354 return libname, version
2355 }
2356 return name, ""
2357}
2358
Dan Albert92fe7402020-07-15 13:33:30 -07002359func GetCrtVariations(ctx android.BottomUpMutatorContext,
2360 m LinkableInterface) []blueprint.Variation {
2361 if ctx.Os() != android.Android {
2362 return nil
2363 }
2364 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002365 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2366 minSdkVersion := m.MinSdkVersion()
2367 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2368 minSdkVersion = m.SdkVersion()
2369 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002370 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2371 if err != nil {
2372 ctx.PropertyErrorf("min_sdk_version", err.Error())
2373 }
Colin Cross363ec762023-01-13 13:45:14 -08002374
2375 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002376 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002377 if apiLevel.LessThan(minApiForArch) {
2378 apiLevel = minApiForArch
2379 }
2380
Dan Albert92fe7402020-07-15 13:33:30 -07002381 return []blueprint.Variation{
2382 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002383 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002384 }
2385 }
2386 return []blueprint.Variation{
2387 {Mutator: "sdk", Variation: ""},
2388 }
2389}
2390
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002391func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2392 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002393
2394 variations = append([]blueprint.Variation(nil), variations...)
2395
Liz Kammer23942242022-04-08 15:41:00 -04002396 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002397 // Version is explicitly specified. i.e. libFoo#30
2398 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002399 if tag, ok := depTag.(libraryDependencyTag); ok {
2400 tag.explicitlyVersioned = true
2401 } else {
2402 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2403 }
Colin Crosse7257d22020-09-24 09:56:18 -07002404 }
Colin Crosse7257d22020-09-24 09:56:18 -07002405
Colin Cross0de8a1e2020-09-18 14:15:30 -07002406 if far {
2407 ctx.AddFarVariationDependencies(variations, depTag, name)
2408 } else {
2409 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002410 }
2411}
2412
Kiyoung Kim487689e2022-07-26 09:48:22 +09002413func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2414 apiImportInfo := multitree.ApiImportInfo{}
2415
2416 if c.Device() {
2417 var apiImportModule []blueprint.Module
2418 if actx.OtherModuleExists("api_imports") {
2419 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2420 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
Colin Cross313aa542023-12-13 13:47:44 -08002421 apiInfo, _ := android.OtherModuleProvider(actx, apiImportModule[0], multitree.ApiImportsProvider)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002422 apiImportInfo = apiInfo
Colin Cross40213022023-12-13 15:19:49 -08002423 android.SetProvider(actx, multitree.ApiImportsProvider, apiInfo)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002424 }
2425 }
2426 }
2427
2428 return apiImportInfo
2429}
2430
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002431func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002432 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002433 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002434 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002435 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2436 // between the modules in the snapshot and the snapshot itself.
2437 var snapshotModule []blueprint.Module
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +09002438 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() && actx.OtherModuleExists("vendor_snapshot") {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002439 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +09002440 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() && actx.OtherModuleExists("recovery_snapshot") {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002441 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2442 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002443 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Colin Cross313aa542023-12-13 13:47:44 -08002444 snapshot, _ := android.OtherModuleProvider(actx, snapshotModule[0], SnapshotInfoProvider)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002445 *snapshotInfo = &snapshot
2446 // republish the snapshot for use in later mutators on this module
Colin Cross40213022023-12-13 15:19:49 -08002447 android.SetProvider(actx, SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002448 }
2449 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002450 if *snapshotInfo == nil {
2451 *snapshotInfo = &SnapshotInfo{}
2452 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002453 return **snapshotInfo
2454}
2455
Kiyoung Kim487689e2022-07-26 09:48:22 +09002456func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2457 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002458 return snapshot
2459 }
2460
2461 return lib
2462}
2463
2464// RewriteLibs takes a list of names of shared libraries and scans it for three types
2465// of names:
2466//
2467// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002468//
2469// For each of these, it adds the name of the prebuilt module (which will be in
2470// prebuilts/ndk) to the list of nonvariant libs.
2471//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002472// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002473//
2474// For each of these, it adds the name of the ndk_library module to the list of
2475// variant libs.
2476//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002477// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002478//
2479// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002480//
2481// The caller can then know to add the variantLibs dependencies differently from the
2482// nonvariantLibs
2483func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2484 variantLibs = []string{}
2485
2486 nonvariantLibs = []string{}
2487 for _, entry := range list {
2488 // strip #version suffix out
2489 name, _ := StubsLibNameAndVersion(entry)
2490 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002491 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002492 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2493 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2494 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002495 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002496 } else {
2497 // put name#version back
2498 nonvariantLibs = append(nonvariantLibs, entry)
2499 }
2500 }
2501 return nonvariantLibs, variantLibs
2502}
2503
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002504func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2505 nonVariantLibs := []string{}
2506 variantLibs := []string{}
2507
2508 for _, lib := range libs {
2509 replaceLibName := GetReplaceModuleName(lib, replaceList)
2510 if replaceLibName == lib {
2511 // Do not handle any libs which are not in API imports
2512 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2513 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2514 variantLibs = append(variantLibs, replaceLibName)
2515 } else {
2516 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2517 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002518 }
2519
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002520 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002521}
2522
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002523func (c *Module) shouldUseApiSurface() bool {
2524 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2525 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2526 // LLNDK Variant
2527 return true
2528 }
2529
2530 if c.Properties.IsSdkVariant {
2531 // NDK Variant
2532 return true
2533 }
2534
2535 if c.isImportedApiLibrary() {
2536 // API Library should depend on API headers
2537 return true
2538 }
2539 }
2540
2541 return false
2542}
2543
Colin Cross1e676be2016-10-12 14:38:15 -07002544func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002545 if !c.Enabled() {
2546 return
2547 }
2548
Colin Cross37047f12016-12-13 17:06:13 -08002549 ctx := &depsContext{
2550 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002551 moduleContextImpl: moduleContextImpl{
2552 mod: c,
2553 },
2554 }
2555 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002556
Colin Crossc99deeb2016-04-11 15:06:20 -07002557 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002558 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002559
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002560 apiNdkLibs := []string{}
2561 apiLateNdkLibs := []string{}
2562
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002563 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002564 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2565 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2566 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2567 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2568 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002569 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002570
Yo Chiang219968c2020-09-22 18:45:04 +08002571 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2572
Colin Crosse0edaf92021-01-11 17:31:17 -08002573 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002574
Dan Albert914449f2016-06-17 16:45:24 -07002575 variantNdkLibs := []string{}
2576 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002577 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002578 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2579 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2580 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002581
2582 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002583 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002584 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002585 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002586
Colin Cross32ec36c2016-12-15 07:39:51 -08002587 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002588 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002589 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002590 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002591 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002592
Kiyoung Kim51279d32022-08-24 14:10:46 +09002593 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002594 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002595 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2596 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002597 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002598
Spandan Das73bcafc2022-08-18 23:26:00 +00002599 if c.isNDKStubLibrary() {
2600 // ndk_headers do not have any variations
2601 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002602 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002603 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002604 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002605 } else {
2606 actx.AddVariationDependencies(nil, depTag, lib)
2607 }
2608 }
2609
Dan Albertf1d14c72020-07-30 14:32:55 -07002610 if c.isNDKStubLibrary() {
2611 // NDK stubs depend on their implementation because the ABI dumps are
2612 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002613
Spandan Das8b08aea2023-03-14 19:29:34 +00002614 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2615 c.ImageVariation(),
2616 blueprint.Variation{Mutator: "link", Variation: "shared"},
2617 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002618 }
2619
Jiyong Park5d1598f2019-02-25 22:14:17 +09002620 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002621 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002622
Kiyoung Kim487689e2022-07-26 09:48:22 +09002623 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002624
Jiyong Park5d1598f2019-02-25 22:14:17 +09002625 actx.AddVariationDependencies([]blueprint.Variation{
2626 {Mutator: "link", Variation: "static"},
2627 }, depTag, lib)
2628 }
2629
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002630 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002631 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002632 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002633 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002634 }
Jiyong Parke3867542020-12-03 17:28:25 +09002635 if inList(lib, deps.ExcludeLibsForApex) {
2636 depTag.excludeInApex = true
2637 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002638
Kiyoung Kim487689e2022-07-26 09:48:22 +09002639 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002640
Dan Willemsen59339a22018-07-22 21:18:45 -07002641 actx.AddVariationDependencies([]blueprint.Variation{
2642 {Mutator: "link", Variation: "static"},
2643 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002644 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002645
Jooyung Han75568392020-03-20 04:29:24 +09002646 // staticUnwinderDep is treated as staticDep for Q apexes
2647 // so that native libraries/binaries are linked with static unwinder
2648 // because Q libc doesn't have unwinder APIs
2649 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002650 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002651 actx.AddVariationDependencies([]blueprint.Variation{
2652 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002653 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002654 }
2655
Jiyong Park7ed9de32018-10-15 22:25:07 +09002656 // shared lib names without the #version suffix
2657 var sharedLibNames []string
2658
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002659 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002660 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002661 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002662 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002663 }
Jiyong Parke3867542020-12-03 17:28:25 +09002664 if inList(lib, deps.ExcludeLibsForApex) {
2665 depTag.excludeInApex = true
2666 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002667 if inList(lib, deps.ExcludeLibsForNonApex) {
2668 depTag.excludeInNonApex = true
2669 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002670
Jiyong Park73c54ee2019-10-22 20:31:18 +09002671 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002672 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2673 name = apiLibraryName
2674 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002675 sharedLibNames = append(sharedLibNames, name)
2676
Colin Crosse7257d22020-09-24 09:56:18 -07002677 variations := []blueprint.Variation{
2678 {Mutator: "link", Variation: "shared"},
2679 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002680
2681 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2682 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2683 }
2684
2685 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2686 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2687 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002688 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002689
Colin Crossfe9acfe2021-06-14 16:13:03 -07002690 for _, lib := range deps.LateStaticLibs {
2691 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2692 actx.AddVariationDependencies([]blueprint.Variation{
2693 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002694 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002695 }
2696
Colin Cross3e5e7782022-06-17 22:17:05 +00002697 for _, lib := range deps.UnexportedStaticLibs {
2698 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2699 actx.AddVariationDependencies([]blueprint.Variation{
2700 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002701 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002702 }
2703
Jiyong Park7ed9de32018-10-15 22:25:07 +09002704 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002705 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002706 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2707 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2708 // linking against both the stubs lib and the non-stubs lib at the same time.
2709 continue
2710 }
Colin Cross6e511a92020-07-27 21:26:48 -07002711 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002712 variations := []blueprint.Variation{
2713 {Mutator: "link", Variation: "shared"},
2714 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002715 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002716 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002717
Dan Willemsen59339a22018-07-22 21:18:45 -07002718 actx.AddVariationDependencies([]blueprint.Variation{
2719 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002720 }, dataLibDepTag, deps.DataLibs...)
2721
Colin Crossc8caa062021-09-24 16:50:14 -07002722 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2723
Chris Parsons79d66a52020-06-05 17:26:16 -04002724 actx.AddVariationDependencies([]blueprint.Variation{
2725 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002726 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002727
Colin Cross68861832016-07-08 10:41:41 -07002728 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002729
2730 for _, gen := range deps.GeneratedHeaders {
2731 depTag := genHeaderDepTag
2732 if inList(gen, deps.ReexportGeneratedHeaders) {
2733 depTag = genHeaderExportDepTag
2734 }
2735 actx.AddDependency(c, depTag, gen)
2736 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002737
Dan Albert92fe7402020-07-15 13:33:30 -07002738 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002739 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002740 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002741 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002742 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002743 }
Colin Crossc465efd2021-06-11 18:00:04 -07002744 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002745 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002746 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002747 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002748 if deps.DynamicLinker != "" {
2749 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002750 }
Dan Albert914449f2016-06-17 16:45:24 -07002751
2752 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002753
2754 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002755 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002756 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002757 {Mutator: "link", Variation: "shared"},
2758 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002759 actx.AddVariationDependencies([]blueprint.Variation{
2760 {Mutator: "version", Variation: version},
2761 {Mutator: "link", Variation: "shared"},
2762 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002763
2764 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002765 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002766 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002767 {Mutator: "link", Variation: "shared"},
2768 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002769 actx.AddVariationDependencies([]blueprint.Variation{
2770 {Mutator: "version", Variation: version},
2771 {Mutator: "link", Variation: "shared"},
2772 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002773
2774 if vndkdep := c.vndkdep; vndkdep != nil {
2775 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002776 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002777 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002778 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002779 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002780 }
2781 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002782
Vinh Tran367d89d2023-04-28 11:21:25 -04002783 if len(deps.AidlLibs) > 0 {
2784 actx.AddDependency(
2785 c,
2786 aidlLibraryTag,
2787 deps.AidlLibs...,
2788 )
2789 }
2790
Kiyoung Kimee58c932022-10-25 22:59:41 +09002791 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002792}
Colin Cross21b9a242015-03-24 14:15:58 -07002793
Colin Crosse40b4ea2018-10-02 22:25:58 -07002794func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002795 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2796 c.beginMutator(ctx)
2797 }
2798}
2799
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002800// Whether a module can link to another module, taking into
2801// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002802func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002803 tag blueprint.DependencyTag) {
2804
2805 switch t := tag.(type) {
2806 case dependencyTag:
2807 if t != vndkExtDepTag {
2808 return
2809 }
2810 case libraryDependencyTag:
2811 default:
2812 return
2813 }
2814
Ivan Lozanof9e21722020-12-02 09:00:51 -05002815 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002816 // Host code is not restricted
2817 return
2818 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002819
2820 // VNDK is cc.Module supported only for now.
2821 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002822 // Though allowed dependency is limited by the image mutator,
2823 // each vendor and product module needs to check link-type
2824 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002825 if ccTo, ok := to.(*Module); ok {
2826 if ccFrom.vndkdep != nil {
2827 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2828 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002829 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002830 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002831 }
2832 return
2833 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002834 // TODO(b/244244438) : Remove this once all variants are implemented
2835 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2836 return
2837 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002838 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002839 // Platform code can link to anything
2840 return
2841 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002842 if from.InRamdisk() {
2843 // Ramdisk code is not NDK
2844 return
2845 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002846 if from.InVendorRamdisk() {
2847 // Vendor ramdisk code is not NDK
2848 return
2849 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002850 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002851 // Recovery code is not NDK
2852 return
2853 }
Colin Cross31076b32020-10-23 17:22:06 -07002854 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002855 if c.NdkPrebuiltStl() {
2856 // These are allowed, but they don't set sdk_version
2857 return
2858 }
2859 if c.StubDecorator() {
2860 // These aren't real libraries, but are the stub shared libraries that are included in
2861 // the NDK.
2862 return
2863 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002864 if c.isImportedApiLibrary() {
2865 // Imported library from the API surface is a stub library built against interface definition.
2866 return
2867 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002868 }
Logan Chien834b9a62019-01-14 15:39:03 +08002869
Ivan Lozano52767be2019-10-18 14:49:46 -07002870 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002871 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2872 // to link to libc++ (non-NDK and without sdk_version).
2873 return
2874 }
2875
Ivan Lozano52767be2019-10-18 14:49:46 -07002876 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002877 // NDK code linking to platform code is never okay.
2878 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002879 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002880 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002881 }
2882
2883 // At this point we know we have two NDK libraries, but we need to
2884 // check that we're not linking against anything built against a higher
2885 // API level, as it is only valid to link against older or equivalent
2886 // APIs.
2887
Inseob Kim01a28722018-04-11 09:48:45 +09002888 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002889 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002890 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002891 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002892 // Current can't be linked against by anything else.
2893 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002894 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002895 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002896 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002897 if err != nil {
2898 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002899 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002900 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002901 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002902 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002903 if err != nil {
2904 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002905 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002906 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002907 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002908
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002909 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002910 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002911 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002912 }
2913 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002914 }
Dan Albert202fe492017-12-15 13:56:59 -08002915
2916 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002917 fromStl := from.SelectedStl()
2918 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002919 if fromStl == "" || toStl == "" {
2920 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002921 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002922 // We can be permissive with the system "STL" since it is only the C++
2923 // ABI layer, but in the future we should make sure that everyone is
2924 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002925 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002926 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002927 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2928 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002929 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002930}
2931
Jooyung Han479ca172020-10-19 18:51:07 +09002932func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2933 if c, ok := ctx.Module().(*Module); ok {
2934 ctx.VisitDirectDeps(func(dep android.Module) {
2935 depTag := ctx.OtherModuleDependencyTag(dep)
2936 ccDep, ok := dep.(LinkableInterface)
2937 if ok {
2938 checkLinkType(ctx, c, ccDep, depTag)
2939 }
2940 })
2941 }
2942}
2943
Jiyong Park5fb8c102018-04-09 12:03:06 +09002944// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002945// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2946// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002947// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002948func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2949 check := func(child, parent android.Module) bool {
2950 to, ok := child.(*Module)
2951 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002952 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002953 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002954
Jooyung Hana70f0672019-01-18 15:20:43 +09002955 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2956 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002957 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002958
Jiyong Park0474e1f2021-01-14 14:26:06 +09002959 // These dependencies are not excercised at runtime. Tracking these will give us
2960 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002961 depTag := ctx.OtherModuleDependencyTag(child)
2962 if IsHeaderDepTag(depTag) {
2963 return false
2964 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002965 if depTag == staticVariantTag {
2966 return false
2967 }
2968 if depTag == stubImplDepTag {
2969 return false
2970 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002971
Justin Yun63e9ec72020-10-29 16:49:43 +09002972 // Even if target lib has no vendor variant, keep checking dependency
2973 // graph in case it depends on vendor_available or product_available
2974 // but not double_loadable transtively.
2975 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002976 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002977 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002978
Jiyong Park0474e1f2021-01-14 14:26:06 +09002979 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2980 // one.
2981 if Bool(to.VendorProperties.Double_loadable) {
2982 return true
2983 }
2984
Ivan Lozanod7586b62021-04-01 09:49:36 -04002985 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002986 return false
2987 }
2988
Jooyung Hana70f0672019-01-18 15:20:43 +09002989 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2990 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002991 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002992 return false
2993 }
2994 if module, ok := ctx.Module().(*Module); ok {
2995 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002996 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002997 ctx.WalkDeps(check)
2998 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002999 }
3000 }
3001}
3002
Yu Liue4312402023-01-18 09:15:31 -08003003func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
3004 // For the dependency from platform to apex, use the latest stubs
3005 apexSdkVersion := android.FutureApiLevel
3006 if !apexInfo.IsForPlatform() {
3007 apexSdkVersion = apexInfo.MinSdkVersion
3008 }
3009
3010 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
3011 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
3012 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
3013 // (b/144430859)
3014 apexSdkVersion = android.FutureApiLevel
3015 }
3016
3017 return apexSdkVersion
3018}
3019
Colin Crossc99deeb2016-04-11 15:06:20 -07003020// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07003021func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08003022 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08003023
Colin Cross0de8a1e2020-09-18 14:15:30 -07003024 var directStaticDeps []StaticLibraryInfo
3025 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07003026
Colin Cross0de8a1e2020-09-18 14:15:30 -07003027 reexportExporter := func(exporter FlagExporterInfo) {
3028 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
3029 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
3030 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
3031 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
3032 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09003033 }
3034
Colin Crossff694a82023-12-13 15:54:49 -08003035 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08003036 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09003037
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003038 skipModuleList := map[string]bool{}
3039
3040 var apiImportInfo multitree.ApiImportInfo
3041 hasApiImportInfo := false
3042
3043 ctx.VisitDirectDeps(func(dep android.Module) {
3044 if dep.Name() == "api_imports" {
Colin Cross313aa542023-12-13 13:47:44 -08003045 apiImportInfo, _ = android.OtherModuleProvider(ctx, dep, multitree.ApiImportsProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003046 hasApiImportInfo = true
3047 }
3048 })
3049
3050 if hasApiImportInfo {
3051 targetStubModuleList := map[string]string{}
3052 targetOrigModuleList := map[string]string{}
3053
3054 // Search for dependency which both original module and API imported library with APEX stub exists
3055 ctx.VisitDirectDeps(func(dep android.Module) {
3056 depName := ctx.OtherModuleName(dep)
3057 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
3058 targetStubModuleList[apiLibrary] = depName
3059 }
3060 })
3061 ctx.VisitDirectDeps(func(dep android.Module) {
3062 depName := ctx.OtherModuleName(dep)
3063 if origLibrary, ok := targetStubModuleList[depName]; ok {
3064 targetOrigModuleList[origLibrary] = depName
3065 }
3066 })
3067
3068 // Decide which library should be used between original and API imported library
3069 ctx.VisitDirectDeps(func(dep android.Module) {
3070 depName := ctx.OtherModuleName(dep)
3071 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00003072 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003073 skipModuleList[depName] = true
3074 } else {
3075 skipModuleList[apiLibrary] = true
3076 }
3077 }
3078 })
3079 }
3080
Colin Crossd11fcda2017-10-23 17:59:01 -07003081 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003082 depName := ctx.OtherModuleName(dep)
3083 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07003084
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003085 if _, ok := skipModuleList[depName]; ok {
3086 // skip this module because original module or API imported module matching with this should be used instead.
3087 return
3088 }
3089
Dan Willemsen47450072021-10-19 20:24:49 -07003090 if depTag == android.DarwinUniversalVariantTag {
3091 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3092 return
3093 }
3094
Vinh Tran367d89d2023-04-28 11:21:25 -04003095 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08003096 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04003097 depPaths.AidlLibraryInfos = append(
3098 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08003099 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04003100 )
3101 }
3102 }
3103
Ivan Lozano52767be2019-10-18 14:49:46 -07003104 ccDep, ok := dep.(LinkableInterface)
3105 if !ok {
3106
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003107 // handling for a few module types that aren't cc Module but that are also supported
3108 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003109 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003110 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003111 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3112 genRule.GeneratedSourceFiles()...)
3113 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003114 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003115 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003116 // Support exported headers from a generated_sources dependency
3117 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003118 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003119 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003120 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003121 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003122 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003123 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003124 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003125 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003126 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3127 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003128 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003129 // 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 +09003130 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003131
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003132 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003133 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003134 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003135 }
Colin Crosscef792e2021-06-11 18:01:26 -07003136 case CrtBeginDepTag:
3137 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3138 case CrtEndDepTag:
3139 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003140 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003141 return
3142 }
3143
Colin Crossfe17f6f2019-03-28 19:30:56 -07003144 if depTag == android.ProtoPluginDepTag {
3145 return
3146 }
3147
Colin Crossd11fcda2017-10-23 17:59:01 -07003148 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003149 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3150 return
3151 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003152 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003153 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3154 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003155 return
3156 }
3157
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003158 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003159 // Skip reused objects for stub libraries, they use their own stub object file instead.
3160 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3161 // version mutator, so the stubs variant is created from the shared variant that
3162 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003163 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003164 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003165 objs := staticAnalogue.ReuseObjects
3166 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003167 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003168 reexportExporter(depExporterInfo)
3169 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003170 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003171 }
3172
Colin Cross6e511a92020-07-27 21:26:48 -07003173 linkFile := ccDep.OutputFile()
3174
3175 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3176 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003177 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003178 return
3179 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003180
Jiyong Parke3867542020-12-03 17:28:25 +09003181 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3182 return
3183 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003184 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3185 return
3186 }
Jiyong Parke3867542020-12-03 17:28:25 +09003187
Colin Cross313aa542023-12-13 13:47:44 -08003188 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003189
Colin Cross6e511a92020-07-27 21:26:48 -07003190 var ptr *android.Paths
3191 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003192
Colin Cross6e511a92020-07-27 21:26:48 -07003193 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003194
Colin Cross6e511a92020-07-27 21:26:48 -07003195 switch {
3196 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003197 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003198 if !ctx.Config().AllowMissingDependencies() {
3199 ctx.ModuleErrorf("module %q is not a header library", depName)
3200 } else {
3201 ctx.AddMissingDependencies([]string{depName})
3202 }
3203 return
3204 }
Colin Cross6e511a92020-07-27 21:26:48 -07003205 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003206 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003207 if !ctx.Config().AllowMissingDependencies() {
3208 ctx.ModuleErrorf("module %q is not a shared library", depName)
3209 } else {
3210 ctx.AddMissingDependencies([]string{depName})
3211 }
3212 return
3213 }
Jiyong Parke3867542020-12-03 17:28:25 +09003214
Jiyong Park7d55b612021-06-11 17:22:09 +09003215 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3216 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003217
Jiyong Park1ad8e162020-12-01 23:40:09 +09003218 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3219 // linkFile, depFile, and ptr.
3220 if c.IsStubs() {
3221 break
3222 }
3223
Colin Cross0de8a1e2020-09-18 14:15:30 -07003224 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3225 depFile = sharedLibraryInfo.TableOfContents
3226
Colin Cross6e511a92020-07-27 21:26:48 -07003227 ptr = &depPaths.SharedLibs
3228 switch libDepTag.Order {
3229 case earlyLibraryDependency:
3230 ptr = &depPaths.EarlySharedLibs
3231 depPtr = &depPaths.EarlySharedLibsDeps
3232 case normalLibraryDependency:
3233 ptr = &depPaths.SharedLibs
3234 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003235 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003236 case lateLibraryDependency:
3237 ptr = &depPaths.LateSharedLibs
3238 depPtr = &depPaths.LateSharedLibsDeps
3239 default:
3240 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003241 }
Colin Cross6e511a92020-07-27 21:26:48 -07003242 case libDepTag.static():
Colin Cross313aa542023-12-13 13:47:44 -08003243 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3244 if !isStaticLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003245 if !ctx.Config().AllowMissingDependencies() {
3246 ctx.ModuleErrorf("module %q is not a static library", depName)
3247 } else {
3248 ctx.AddMissingDependencies([]string{depName})
3249 }
3250 return
3251 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003252
3253 // Stubs lib doesn't link to the static lib dependencies. Don't set
3254 // linkFile, depFile, and ptr.
3255 if c.IsStubs() {
3256 break
3257 }
3258
Colin Cross0de8a1e2020-09-18 14:15:30 -07003259 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003260 if libDepTag.wholeStatic {
3261 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003262 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3263 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003264 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003265 // This case normally catches prebuilt static
3266 // libraries, but it can also occur when
3267 // AllowMissingDependencies is on and the
3268 // dependencies has no sources of its own
3269 // but has a whole_static_libs dependency
3270 // on a missing library. We want to depend
3271 // on the .a file so that there is something
3272 // in the dependency tree that contains the
3273 // error rule for the missing transitive
3274 // dependency.
3275 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003276 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003277 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3278 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003279 } else {
3280 switch libDepTag.Order {
3281 case earlyLibraryDependency:
3282 panic(fmt.Errorf("early static libs not suppported"))
3283 case normalLibraryDependency:
3284 // static dependencies will be handled separately so they can be ordered
3285 // using transitive dependencies.
3286 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003287 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003288 case lateLibraryDependency:
3289 ptr = &depPaths.LateStaticLibs
3290 default:
3291 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003292 }
3293 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003294 if libDepTag.unexportedSymbols {
3295 depPaths.LdFlags = append(depPaths.LdFlags,
3296 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3297 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003298 }
3299
Colin Cross6e511a92020-07-27 21:26:48 -07003300 if libDepTag.static() && !libDepTag.wholeStatic {
3301 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3302 ctx.ModuleErrorf("module %q not a static library", depName)
3303 return
3304 }
Logan Chien43d34c32017-12-20 01:17:32 +08003305
Colin Cross6e511a92020-07-27 21:26:48 -07003306 // When combining coverage files for shared libraries and executables, coverage files
3307 // in static libraries act as if they were whole static libraries. The same goes for
3308 // source based Abi dump files.
3309 if c, ok := ccDep.(*Module); ok {
3310 staticLib := c.linker.(libraryInterface)
3311 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3312 staticLib.objs().coverageFiles...)
3313 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3314 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003315 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003316 // Handle non-CC modules here
3317 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003318 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003319 }
3320 }
3321
Colin Cross6e511a92020-07-27 21:26:48 -07003322 if ptr != nil {
3323 if !linkFile.Valid() {
3324 if !ctx.Config().AllowMissingDependencies() {
3325 ctx.ModuleErrorf("module %q missing output file", depName)
3326 } else {
3327 ctx.AddMissingDependencies([]string{depName})
3328 }
3329 return
3330 }
3331 *ptr = append(*ptr, linkFile.Path())
3332 }
3333
3334 if depPtr != nil {
3335 dep := depFile
3336 if !dep.Valid() {
3337 dep = linkFile
3338 }
3339 *depPtr = append(*depPtr, dep.Path())
3340 }
3341
Colin Cross0de8a1e2020-09-18 14:15:30 -07003342 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3343 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3344 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3345 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3346
3347 if libDepTag.reexportFlags {
3348 reexportExporter(depExporterInfo)
3349 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3350 // Re-exported shared library headers must be included as well since they can help us with type information
3351 // about template instantiations (instantiated from their headers).
3352 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3353 // scripts.
3354 c.sabi.Properties.ReexportedIncludes = append(
3355 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3356 }
3357
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003358 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003359 switch {
3360 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003361 c.Properties.AndroidMkHeaderLibs = append(
3362 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003363 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003364 if lib := moduleLibraryInterface(dep); lib != nil {
3365 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003366 // Add the dependency to the APEX(es) providing the library so that
3367 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003368 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003369 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003370 c.Properties.ApexesProvidingSharedLibs = append(
3371 c.Properties.ApexesProvidingSharedLibs, an)
3372 }
3373 }
3374 }
3375
3376 // Note: the order of libs in this list is not important because
3377 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003378 c.Properties.AndroidMkSharedLibs = append(
3379 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003380 // Record BaseLibName for snapshots.
3381 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003382 case libDepTag.static():
3383 if libDepTag.wholeStatic {
3384 c.Properties.AndroidMkWholeStaticLibs = append(
3385 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3386 } else {
3387 c.Properties.AndroidMkStaticLibs = append(
3388 c.Properties.AndroidMkStaticLibs, makeLibName)
3389 }
Justin Yun5e035862021-06-29 20:50:37 +09003390 // Record BaseLibName for snapshots.
3391 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003392 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003393 } else if !c.IsStubs() {
3394 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3395
Colin Cross6e511a92020-07-27 21:26:48 -07003396 switch depTag {
3397 case runtimeDepTag:
3398 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003399 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003400 // Record BaseLibName for snapshots.
3401 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003402 case objDepTag:
3403 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3404 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003405 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003406 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003407 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003408 case dynamicLinkerDepTag:
3409 depPaths.DynamicLinker = linkFile
3410 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003411 }
Colin Crossca860ac2016-01-04 14:34:37 -08003412 })
3413
Jeff Gaston294356f2017-09-27 17:05:30 -07003414 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003415 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3416 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3417 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003418
Colin Crossdd84e052017-05-17 13:44:16 -07003419 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003420 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003421 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3422 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003423 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003424 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3425 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003426 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003427 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003428 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003429
3430 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003431 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003432 }
Colin Crossdd84e052017-05-17 13:44:16 -07003433
Colin Crossca860ac2016-01-04 14:34:37 -08003434 return depPaths
3435}
3436
Spandan Das604f3762023-03-16 22:51:40 +00003437func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003438 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003439 thisModule, ok := ctx.Module().(android.ApexModule)
3440 if !ok {
3441 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3442 }
3443
Kiyoung Kimaa394802024-01-08 12:55:45 +09003444 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003445 bootstrap := false
3446 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3447 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3448 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003449 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003450 bootstrap = linkable.Bootstrap()
3451 }
3452
Colin Crossff694a82023-12-13 15:54:49 -08003453 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003454
3455 useStubs := false
3456
Kiyoung Kimaa394802024-01-08 12:55:45 +09003457 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003458 if !apexInfo.IsForPlatform() {
3459 // For platform libraries, use current version of LLNDK
3460 // If this is for use_vendor apex we will apply the same rules
3461 // of apex sdk enforcement below to choose right version.
3462 useStubs = true
3463 }
3464 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3465 // If not building for APEX or the containing APEX allows the use of
3466 // platform APIs, use stubs only when it is from an APEX (and not from
3467 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3468 // bootstrap modules, always link to non-stub variant
3469 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3470
3471 isApexImportedApiLibrary := false
3472
3473 if cc, ok := dep.(*Module); ok {
3474 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3475 if apiLibrary.hasApexStubs() {
3476 isApexImportedApiLibrary = true
3477 }
3478 }
3479 }
3480
3481 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3482
3483 if useStubs {
3484 // Another exception: if this module is a test for an APEX, then
3485 // it is linked with the non-stub variant of a module in the APEX
3486 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003487 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003488 for _, apexContents := range testFor.ApexContents {
3489 if apexContents.DirectlyInApex(depName) {
3490 useStubs = false
3491 break
3492 }
3493 }
3494 }
3495 if useStubs {
3496 // Yet another exception: If this module and the dependency are
3497 // available to the same APEXes then skip stubs between their
3498 // platform variants. This complements the test_for case above,
3499 // which avoids the stubs on a direct APEX library dependency, by
3500 // avoiding stubs for indirect test dependencies as well.
3501 //
3502 // TODO(b/183882457): This doesn't work if the two libraries have
3503 // only partially overlapping apex_available. For that test_for
3504 // modules would need to be split into APEX variants and resolved
3505 // separately for each APEX they have access to.
3506 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3507 useStubs = false
3508 }
3509 }
3510 } else {
3511 // If building for APEX, use stubs when the parent is in any APEX that
3512 // the child is not in.
3513 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3514 }
3515
3516 return useStubs
3517}
3518
3519// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3520// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3521// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3522// has different level of updatability. For example, if a library foo in an APEX depends on a
3523// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3524// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3525// same APEX as foo, the non-stub variant of bar is used.
3526func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3527 depTag := ctx.OtherModuleDependencyTag(dep)
3528 libDepTag, ok := depTag.(libraryDependencyTag)
3529 if !ok || !libDepTag.shared() {
3530 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3531 }
3532
Colin Cross313aa542023-12-13 13:47:44 -08003533 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3534 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3535 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003536
3537 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003538 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003539 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003540 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3541 toUse := stubs[len(stubs)-1]
3542 sharedLibraryInfo = toUse.SharedLibraryInfo
3543 depExporterInfo = toUse.FlagExporterInfo
3544 }
3545 }
3546 return sharedLibraryInfo, depExporterInfo
3547}
3548
Colin Cross0de8a1e2020-09-18 14:15:30 -07003549// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3550// to match the topological order of the dependency tree, including any static analogues of
3551// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3552// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003553func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3554 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003555 var staticPaths android.Paths
3556 for _, staticDep := range staticDeps {
3557 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3558 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3559 }
3560 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003561 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3562 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003563 }
3564 }
3565 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3566
3567 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3568
3569 // reorder the dependencies based on transitive dependencies
3570 staticPaths = android.FirstUniquePaths(staticPaths)
3571 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3572
3573 if len(orderedStaticPaths) != len(staticPaths) {
3574 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3575 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3576 }
3577
3578 return orderedStaticPaths, transitiveStaticLibs
3579}
3580
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003581// BaseLibName trims known prefixes and suffixes
3582func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003583 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3584 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003585 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003586 return libName
3587}
3588
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003589func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003590 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003591 ccDepModule, _ := ccDep.(*Module)
3592 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003593 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003594
Justin Yuncbca3732021-02-03 19:24:13 +09003595 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003596 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003597 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003598 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003599
Ivan Lozanod1dec542021-05-26 15:33:11 -04003600 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003601 }
3602 }
3603
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003604 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3605 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003606 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3607 // core module instead.
3608 return libName
Kiyoung Kimaa394802024-01-08 12:55:45 +09003609 } else if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003610 // The vendor and product modules in Make will have been renamed to not conflict with the
3611 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003612 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003613 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003614 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003615 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003616 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003617 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003618 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003619 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003620 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003621 } else {
3622 return libName
3623 }
3624}
3625
Colin Crossca860ac2016-01-04 14:34:37 -08003626func (c *Module) InstallInData() bool {
3627 if c.installer == nil {
3628 return false
3629 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003630 return c.installer.inData()
3631}
3632
3633func (c *Module) InstallInSanitizerDir() bool {
3634 if c.installer == nil {
3635 return false
3636 }
3637 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003638 return true
3639 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003640 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003641}
3642
Yifan Hong1b3348d2020-01-21 15:53:22 -08003643func (c *Module) InstallInRamdisk() bool {
3644 return c.InRamdisk()
3645}
3646
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003647func (c *Module) InstallInVendorRamdisk() bool {
3648 return c.InVendorRamdisk()
3649}
3650
Jiyong Parkf9332f12018-02-01 00:54:12 +09003651func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003652 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003653}
3654
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003655func (c *Module) MakeUninstallable() {
3656 if c.installer == nil {
3657 c.ModuleBase.MakeUninstallable()
3658 return
3659 }
3660 c.installer.makeUninstallable(c)
3661}
3662
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003663func (c *Module) HostToolPath() android.OptionalPath {
3664 if c.installer == nil {
3665 return android.OptionalPath{}
3666 }
3667 return c.installer.hostToolPath()
3668}
3669
Nan Zhangd4e641b2017-07-12 12:55:28 -07003670func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3671 return c.outputFile
3672}
3673
Colin Cross41955e82019-05-29 14:40:35 -07003674func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3675 switch tag {
3676 case "":
3677 if c.outputFile.Valid() {
3678 return android.Paths{c.outputFile.Path()}, nil
3679 }
3680 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003681 case "unstripped":
3682 if c.linker != nil {
3683 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3684 }
3685 return nil, nil
Wei Li5f5d2712023-12-11 15:40:29 -08003686 case "stripped_all":
3687 if c.linker != nil {
3688 return android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), nil
3689 }
3690 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003691 default:
3692 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003693 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003694}
3695
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003696func (c *Module) static() bool {
3697 if static, ok := c.linker.(interface {
3698 static() bool
3699 }); ok {
3700 return static.static()
3701 }
3702 return false
3703}
3704
Jiyong Park379de2f2018-12-19 02:47:14 +09003705func (c *Module) staticBinary() bool {
3706 if static, ok := c.linker.(interface {
3707 staticBinary() bool
3708 }); ok {
3709 return static.staticBinary()
3710 }
3711 return false
3712}
3713
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003714func (c *Module) testBinary() bool {
3715 if test, ok := c.linker.(interface {
3716 testBinary() bool
3717 }); ok {
3718 return test.testBinary()
3719 }
3720 return false
3721}
3722
Jingwen Chen537242c2022-08-24 11:53:27 +00003723func (c *Module) testLibrary() bool {
3724 if test, ok := c.linker.(interface {
3725 testLibrary() bool
3726 }); ok {
3727 return test.testLibrary()
3728 }
3729 return false
3730}
3731
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003732func (c *Module) benchmarkBinary() bool {
3733 if b, ok := c.linker.(interface {
3734 benchmarkBinary() bool
3735 }); ok {
3736 return b.benchmarkBinary()
3737 }
3738 return false
3739}
3740
3741func (c *Module) fuzzBinary() bool {
3742 if f, ok := c.linker.(interface {
3743 fuzzBinary() bool
3744 }); ok {
3745 return f.fuzzBinary()
3746 }
3747 return false
3748}
3749
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003750// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3751func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003752 if h, ok := c.linker.(interface {
3753 header() bool
3754 }); ok {
3755 return h.header()
3756 }
3757 return false
3758}
3759
Ivan Lozanod7586b62021-04-01 09:49:36 -04003760func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003761 if b, ok := c.linker.(interface {
3762 binary() bool
3763 }); ok {
3764 return b.binary()
3765 }
3766 return false
3767}
3768
Justin Yun5e035862021-06-29 20:50:37 +09003769func (c *Module) StaticExecutable() bool {
3770 if b, ok := c.linker.(*binaryDecorator); ok {
3771 return b.static()
3772 }
3773 return false
3774}
3775
Ivan Lozanod7586b62021-04-01 09:49:36 -04003776func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003777 if o, ok := c.linker.(interface {
3778 object() bool
3779 }); ok {
3780 return o.object()
3781 }
3782 return false
3783}
3784
Ivan Lozanof9e21722020-12-02 09:00:51 -05003785func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003786 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003787 if c.IsLlndk() {
3788 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003789 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003790 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003791 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003792 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003793 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003794 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003795 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003796 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003797 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003798 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003799 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003800 return "native:product"
3801 }
Jooyung Han38002912019-05-16 04:01:54 +09003802 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003803 } else if c.InRamdisk() {
3804 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003805 } else if c.InVendorRamdisk() {
3806 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003807 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003808 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003809 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003810 return "native:ndk:none:none"
3811 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3812 //family, link := getNdkStlFamilyAndLinkType(c)
3813 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003814 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003815 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003816 } else {
3817 return "native:platform"
3818 }
3819}
3820
Jiyong Park9d452992018-10-03 00:38:19 +09003821// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003822// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003823func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003824 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003825 // Stub libs and prebuilt libs in a versioned SDK are not
3826 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003827 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003828 } else if _, ok := c.linker.(testPerSrc); ok {
3829 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003830 }
3831 return false
3832}
3833
Jiyong Parka90ca002019-10-07 15:47:24 +09003834func (c *Module) AvailableFor(what string) bool {
3835 if linker, ok := c.linker.(interface {
3836 availableFor(string) bool
3837 }); ok {
3838 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3839 } else {
3840 return c.ApexModuleBase.AvailableFor(what)
3841 }
3842}
3843
Jiyong Park62304bb2020-04-13 16:19:48 +09003844func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003845 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003846}
3847
Paul Duffin0cb37b92020-03-04 14:52:46 +00003848func (c *Module) EverInstallable() bool {
3849 return c.installer != nil &&
3850 // Check to see whether the module is actually ever installable.
3851 c.installer.everInstallable()
3852}
3853
Ivan Lozanod7586b62021-04-01 09:49:36 -04003854func (c *Module) PreventInstall() bool {
3855 return c.Properties.PreventInstall
3856}
3857
3858func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003859 if c.library != nil {
3860 if i := c.library.installable(); i != nil {
3861 return i
3862 }
3863 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003864 return c.Properties.Installable
3865}
3866
3867func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003868 ret := c.EverInstallable() &&
3869 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003870 proptools.BoolDefault(c.Installable(), true) &&
3871 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003872
3873 // The platform variant doesn't need further condition. Apex variants however might not
3874 // be installable because it will likely to be included in the APEX and won't appear
3875 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003876 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003877 return ret
3878 }
3879
3880 // Special case for modules that are configured to be installed to /data, which includes
3881 // test modules. For these modules, both APEX and non-APEX variants are considered as
3882 // installable. This is because even the APEX variants won't be included in the APEX, but
3883 // will anyway be installed to /data/*.
3884 // See b/146995717
3885 if c.InstallInData() {
3886 return ret
3887 }
3888
3889 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003890}
3891
Logan Chien41eabe62019-04-10 13:33:58 +08003892func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3893 if c.linker != nil {
3894 if library, ok := c.linker.(*libraryDecorator); ok {
3895 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3896 }
3897 }
3898}
3899
Jiyong Park45bf82e2020-12-15 22:29:02 +09003900var _ android.ApexModule = (*Module)(nil)
3901
3902// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003903func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003904 depTag := ctx.OtherModuleDependencyTag(dep)
3905 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3906
3907 if cc, ok := dep.(*Module); ok {
3908 if cc.HasStubsVariants() {
3909 if isLibDepTag && libDepTag.shared() {
3910 // dynamic dep to a stubs lib crosses APEX boundary
3911 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003912 }
Colin Cross6e511a92020-07-27 21:26:48 -07003913 if IsRuntimeDepTag(depTag) {
3914 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003915 return false
3916 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003917 }
Zhijun Heec285872021-04-24 10:47:08 -07003918 if cc.IsLlndk() {
3919 return false
3920 }
Colin Crossaac32222020-07-29 12:51:56 -07003921 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003922 // shared_lib dependency from a static lib is considered as crossing
3923 // the APEX boundary because the dependency doesn't actually is
3924 // linked; the dependency is used only during the compilation phase.
3925 return false
3926 }
Jiyong Parke3867542020-12-03 17:28:25 +09003927
3928 if isLibDepTag && libDepTag.excludeInApex {
3929 return false
3930 }
Colin Cross6e511a92020-07-27 21:26:48 -07003931 }
Colin Crossc1b36442021-05-06 13:42:48 -07003932 if depTag == stubImplDepTag {
3933 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003934 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003935 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003936 if depTag == staticVariantTag {
3937 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3938 // actually mean that the static lib (and its dependencies) are copied into the
3939 // APEX.
3940 return false
3941 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003942 return true
3943}
3944
Jiyong Park45bf82e2020-12-15 22:29:02 +09003945// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003946func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3947 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003948 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3949 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3950 return nil
3951 }
Jooyung Han749dc692020-04-15 11:03:39 +09003952 // We don't check for prebuilt modules
3953 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3954 return nil
3955 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003956
Jooyung Han749dc692020-04-15 11:03:39 +09003957 minSdkVersion := c.MinSdkVersion()
3958 if minSdkVersion == "apex_inherit" {
3959 return nil
3960 }
3961 if minSdkVersion == "" {
3962 // JNI libs within APK-in-APEX fall into here
3963 // Those are okay to set sdk_version instead
3964 // We don't have to check if this is a SDK variant because
3965 // non-SDK variant resets sdk_version, which works too.
3966 minSdkVersion = c.SdkVersion()
3967 }
Dan Albertc8060532020-07-22 22:32:17 -07003968 if minSdkVersion == "" {
3969 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3970 }
3971 // Not using nativeApiLevelFromUser because the context here is not
3972 // necessarily a native context.
3973 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003974 if err != nil {
3975 return err
3976 }
Dan Albertc8060532020-07-22 22:32:17 -07003977
Colin Cross8ca61c12022-10-06 21:00:14 -07003978 // A dependency only needs to support a min_sdk_version at least
3979 // as high as the api level that the architecture was introduced in.
3980 // This allows introducing new architectures in the platform that
3981 // need to be included in apexes that normally require an older
3982 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003983 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003984 if sdkVersion.LessThan(minApiForArch) {
3985 sdkVersion = minApiForArch
3986 }
3987
Dan Albertc8060532020-07-22 22:32:17 -07003988 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003989 return fmt.Errorf("newer SDK(%v)", ver)
3990 }
3991 return nil
3992}
3993
Paul Duffinb5769c12021-05-12 16:16:51 +01003994// Implements android.ApexModule
3995func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3996 // stub libraries and native bridge libraries are always available to platform
3997 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3998}
3999
Jooyung Han91f92032022-02-04 12:36:33 +09004000// Overrides android.ApexModuleBase.UniqueApexVariations
4001func (c *Module) UniqueApexVariations() bool {
4002 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
4003 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
4004 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09004005 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09004006 return c.UseVndk() && c.IsVndk()
4007}
4008
Inseob Kima1888ce2022-10-04 14:42:02 +09004009func (c *Module) overriddenModules() []string {
4010 if o, ok := c.linker.(overridable); ok {
4011 return o.overriddenModules()
4012 }
4013 return nil
4014}
4015
Rob Seymour925aa092021-08-10 20:42:03 +00004016var _ snapshot.RelativeInstallPath = (*Module)(nil)
4017
Liz Kammer35ca77e2021-12-22 15:31:40 -05004018type moduleType int
4019
4020const (
4021 unknownType moduleType = iota
4022 binary
4023 object
4024 fullLibrary
4025 staticLibrary
4026 sharedLibrary
4027 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00004028 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00004029 ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00004030 ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05004031)
4032
4033func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00004034 if c.testBinary() {
4035 // testBinary is also a binary, so this comes before the c.Binary()
4036 // conditional. A testBinary has additional implicit dependencies and
4037 // other test-only semantics.
4038 return testBin
4039 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004040 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004041 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004042 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00004043 } else if c.testLibrary() {
4044 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
4045 // will let them add implicit compile deps on gtest, for example.
4046 //
Liz Kammerefc51d92023-04-21 15:11:25 -04004047 // For now, treat them as regular libraries.
4048 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004049 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05004050 static := false
4051 shared := false
4052 if library, ok := c.linker.(*libraryDecorator); ok {
4053 static = library.MutatedProperties.BuildStatic
4054 shared = library.MutatedProperties.BuildShared
4055 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
4056 static = library.MutatedProperties.BuildStatic
4057 shared = library.MutatedProperties.BuildShared
4058 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004059 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004060 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004061 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004062 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004063 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004064 return staticLibrary
4065 }
4066 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00004067 } else if c.isNDKStubLibrary() {
4068 return ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00004069 } else if c.IsNdkPrebuiltStl() {
4070 return ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05004071 }
4072 return unknownType
4073}
4074
Colin Crosscfad1192015-11-02 16:43:11 -08004075// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004076type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004077 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004078 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004079 android.ApexModuleBase
LaMont Jonesafe7baf2024-01-09 22:47:39 +00004080
4081 // Aconfig files for all transitive deps. Also exposed via TransitiveDeclarationsInfo
4082 mergedAconfigFiles map[string]android.Paths
Colin Crosscfad1192015-11-02 16:43:11 -08004083}
4084
Patrice Arrudac249c712019-03-19 17:00:29 -07004085// cc_defaults provides a set of properties that can be inherited by other cc
4086// modules. A module can use the properties from a cc_defaults using
4087// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4088// merged (when possible) by prepending the default module's values to the
4089// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004090func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004091 return DefaultsFactory()
4092}
4093
Colin Cross36242852017-06-23 15:06:31 -07004094func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004095 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004096
Colin Cross36242852017-06-23 15:06:31 -07004097 module.AddProperties(props...)
4098 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004099 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004100 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004101 &BaseCompilerProperties{},
4102 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004103 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004104 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004105 &StaticProperties{},
4106 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004107 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004108 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004109 &TestLinkerProperties{},
4110 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004111 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004112 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004113 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004114 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004115 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004116 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004117 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004118 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004119 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004120 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004121 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004122 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004123 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00004124 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004125 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004126 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4127 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004128 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004129 )
Colin Crosscfad1192015-11-02 16:43:11 -08004130
Jooyung Hancc372c52019-09-25 15:18:44 +09004131 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004132
4133 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004134}
4135
Jiyong Park2286afd2020-06-16 21:58:53 +09004136func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004137 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004138}
4139
Kiyoung Kim51279d32022-08-24 14:10:46 +09004140func (c *Module) isImportedApiLibrary() bool {
4141 _, ok := c.linker.(*apiLibraryDecorator)
4142 return ok
4143}
4144
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004145func kytheExtractAllFactory() android.Singleton {
4146 return &kytheExtractAllSingleton{}
4147}
4148
4149type kytheExtractAllSingleton struct {
4150}
4151
4152func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4153 var xrefTargets android.Paths
4154 ctx.VisitAllModules(func(module android.Module) {
4155 if ccModule, ok := module.(xref); ok {
4156 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4157 }
4158 })
4159 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4160 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004161 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004162 }
4163}
4164
Jihoon Kangf78a8902022-09-01 22:47:07 +00004165func (c *Module) Partition() string {
4166 if p, ok := c.installer.(interface {
4167 getPartition() string
4168 }); ok {
4169 return p.getPartition()
4170 }
4171 return ""
4172}
4173
Colin Cross06a931b2015-10-28 17:23:31 -07004174var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004175var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004176var BoolPtr = proptools.BoolPtr
4177var String = proptools.String
4178var StringPtr = proptools.StringPtr