blob: 480d3141e0b09508999a0db0d138b69e7d1f923d [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()
Colin Cross1e676be2016-10-12 14:38:15 -070058 })
Colin Cross16b23492016-01-06 14:41:07 -080059
Paul Duffin036e7002019-12-19 19:16:28 +000060 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040061 for _, san := range Sanitizers {
62 san.registerMutators(ctx)
63 }
Dan Willemsen581341d2017-02-09 16:16:31 -080064
Colin Cross0b908332019-06-19 23:00:20 -070065 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090066 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080067
Cory Barkera1da26f2022-06-07 20:12:06 +000068 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000069
Colin Crossf5f4ad32024-01-19 15:41:48 -080070 ctx.Transition("coverage", &coverageTransitionMutator{})
Stephen Craneba090d12017-05-09 15:44:35 -070071
Colin Crossa6b407f2024-01-23 16:38:06 -080072 ctx.Transition("afdo", &afdoTransitionMutator{})
Yi Kongeb8efc92021-12-09 18:06:29 +080073
Colin Cross33e0c812024-01-23 16:36:07 -080074 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000075
Colin Cross6ac83a82024-01-23 11:23:10 -080076 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +090077
Jooyung Han479ca172020-10-19 18:51:07 +090078 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090079 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070080 })
Colin Crossb98c8b02016-07-29 13:44:28 -070081
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080082 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
83 // sabi mutator needs to be run after apex mutator finishes.
84 ctx.TopDown("sabi_deps", sabiDepsMutator)
85 })
86
LaMont Jones0c10e4d2023-05-16 00:58:37 +000087 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070088}
89
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050090// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
91// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
92// edges to these modules.
93// This object is constructed in DepsMutator, by calling to various module delegates to set
94// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
95// dependencies.
96// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
97// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080098type Deps struct {
99 SharedLibs, LateSharedLibs []string
100 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800101 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800102 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700103
Colin Cross3e5e7782022-06-17 22:17:05 +0000104 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
105 // prevent automatically exporting symbols.
106 UnexportedStaticLibs []string
107
Chris Parsons79d66a52020-06-05 17:26:16 -0400108 // Used for data dependencies adjacent to tests
109 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700110 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400111
Yo Chiang219968c2020-09-22 18:45:04 +0800112 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
113 SystemSharedLibs []string
114
Vinh Tran367d89d2023-04-28 11:21:25 -0400115 // Used by DepMutator to pass aidl_library modules to aidl compiler
116 AidlLibs []string
117
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500118 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800119 StaticUnwinderIfLegacy bool
120
Colin Cross5950f382016-12-13 12:50:57 -0800121 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700122
Colin Cross81413472016-04-11 14:37:39 -0700123 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700124
Dan Willemsenb40aab62016-04-20 14:21:14 -0700125 GeneratedSources []string
126 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900127 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700128
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700129 ReexportGeneratedHeaders []string
130
Colin Crossc465efd2021-06-11 18:00:04 -0700131 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700132
133 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700134 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900135
136 // List of libs that need to be excluded for APEX variant
137 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900138 // List of libs that need to be excluded for non-APEX variant
139 ExcludeLibsForNonApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700140}
141
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500142// PathDeps is a struct containing file paths to dependencies of a module.
143// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
144// It's used to construct flags for various build statements (such as for compiling and linking).
145// It is then passed to module decorator functions responsible for registering build statements
146// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800147type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700148 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900149 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700150 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900151 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700152 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700153 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700154
Colin Cross0de8a1e2020-09-18 14:15:30 -0700155 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossc85750b2022-04-21 12:50:51 -0700156 TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700157
Colin Cross26c34ed2016-09-30 17:10:16 -0700158 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100159 Objs Objects
160 // Paths to .o files in dependencies that provide them. Note that these lists
161 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800162 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700163 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700164
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100165 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
166 // the libs from all whole_static_lib dependencies.
167 WholeStaticLibsFromPrebuilts android.Paths
168
Colin Cross26c34ed2016-09-30 17:10:16 -0700169 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700170 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900171 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700172
Inseob Kimd110f872019-12-06 13:15:38 +0900173 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000174 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900175 IncludeDirs android.Paths
176 SystemIncludeDirs android.Paths
177 ReexportedDirs android.Paths
178 ReexportedSystemDirs android.Paths
179 ReexportedFlags []string
180 ReexportedGeneratedHeaders android.Paths
181 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700182
Colin Cross26c34ed2016-09-30 17:10:16 -0700183 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700184 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700185
Dan Willemsena0790e32018-10-12 00:24:23 -0700186 // Path to the dynamic linker binary
187 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700188
189 // For Darwin builds, the path to the second architecture's output that should
190 // be combined with this architectures's output into a FAT MachO file.
191 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400192
193 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
194 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700195}
196
Colin Cross4af21ed2019-11-04 09:37:55 -0800197// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
198// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
199// command line so they can be overridden by the local module flags).
200type LocalOrGlobalFlags struct {
201 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700202 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800203 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700204 CFlags []string // Flags that apply to C and C++ source files
205 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
206 ConlyFlags []string // Flags that apply to C source files
207 CppFlags []string // Flags that apply to C++ source files
208 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700209 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800210}
211
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500212// Flags contains various types of command line flags (and settings) for use in building build
213// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800214type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500215 // Local flags (which individual modules are responsible for). These may override global flags.
216 Local LocalOrGlobalFlags
217 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800218 Global LocalOrGlobalFlags
219
220 aidlFlags []string // Flags that apply to aidl source files
221 rsFlags []string // Flags that apply to renderscript source files
222 libFlags []string // Flags to add libraries early to the link order
223 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
224 TidyFlags []string // Flags that apply to clang-tidy
225 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700226
Colin Crossc3199482017-03-30 15:03:04 -0700227 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800228 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700229 SystemIncludeFlags []string
230
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800231 Toolchain config.Toolchain
232 Tidy bool // True if ninja .tidy rules should be generated.
233 NeedTidyFiles bool // True if module link should depend on .tidy files
234 GcovCoverage bool // True if coverage files should be generated.
235 SAbiDump bool // True if header abi dumps should be generated.
236 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800237
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500238 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800239 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500240 // The target-device system path to the dynamic linker.
241 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800242
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700243 CFlagsDeps android.Paths // Files depended on by compiler flags
244 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800245
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500246 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700247 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800248
Colin Cross19878da2019-03-28 14:45:07 -0700249 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700250 protoC bool // Whether to use C instead of C++
251 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700252
253 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200254 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700255}
256
Colin Crossca860ac2016-01-04 14:34:37 -0800257// Properties used to compile all C or C++ modules
258type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700259 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800260 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700261
Jiyong Parkb35a8192020-08-10 15:59:36 +0900262 // The API level that this module is built against. The APIs of this API level will be
263 // visible at build time, but use of any APIs newer than min_sdk_version will render the
264 // module unloadable on older devices. In the future it will be possible to weakly-link new
265 // APIs, making the behavior match Java: such modules will load on older devices, but
266 // calling new APIs on devices that do not support them will result in a crash.
267 //
268 // This property has the same behavior as sdk_version does for Java modules. For those
269 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
270 // does for Java code.
271 //
272 // In addition, setting this property causes two variants to be built, one for the platform
273 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800274 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700275
Jiyong Parkb35a8192020-08-10 15:59:36 +0900276 // Minimum OS API level supported by this C or C++ module. This property becomes the value
277 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
278 // this property is also used to ensure that the min_sdk_version of the containing module is
279 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
280 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
281 // min_sdk_version of the containing APEX. When the module
282 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900283 Min_sdk_version *string
284
Colin Crossc511bc52020-04-07 16:50:32 +0000285 // If true, always create an sdk variant and don't create a platform variant.
286 Sdk_variant_only *bool
287
Jiyong Parkde866cb2018-12-07 23:08:36 +0900288 AndroidMkSharedLibs []string `blueprint:"mutated"`
289 AndroidMkStaticLibs []string `blueprint:"mutated"`
290 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
291 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700292 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900293 HideFromMake bool `blueprint:"mutated"`
294 PreventInstall bool `blueprint:"mutated"`
295 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700296
Yo Chiang219968c2020-09-22 18:45:04 +0800297 // Set by DepsMutator.
298 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
299
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900300 // The name of the image this module is built for
301 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200302
303 // The VNDK version this module is built against. If empty, the module is not
304 // build against the VNDK.
305 VndkVersion string `blueprint:"mutated"`
306
307 // Suffix for the name of Android.mk entries generated by this module
308 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800309
310 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
311 // file
312 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900313
Yifan Hong39143a92020-10-26 12:43:12 -0700314 // Make this module available when building for ramdisk.
315 // On device without a dedicated recovery partition, the module is only
316 // available after switching root into
317 // /first_stage_ramdisk. To expose the module before switching root, install
318 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800319 Ramdisk_available *bool
320
Yifan Hong39143a92020-10-26 12:43:12 -0700321 // Make this module available when building for vendor ramdisk.
322 // On device without a dedicated recovery partition, the module is only
323 // available after switching root into
324 // /first_stage_ramdisk. To expose the module before switching root, install
325 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700326 Vendor_ramdisk_available *bool
327
Jiyong Parkf9332f12018-02-01 00:54:12 +0900328 // Make this module available when building for recovery
329 Recovery_available *bool
330
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200331 // Used by imageMutator, set by ImageMutatorBegin()
332 CoreVariantNeeded bool `blueprint:"mutated"`
333 RamdiskVariantNeeded bool `blueprint:"mutated"`
334 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
335 RecoveryVariantNeeded bool `blueprint:"mutated"`
336
337 // A list of variations for the "image" mutator of the form
338 //<image name> '.' <version char>, for example, 'vendor.S'
339 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900340
341 // Allows this module to use non-APEX version of libraries. Useful
342 // for building binaries that are started before APEXes are activated.
343 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900344
345 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
346 // see soong/cc/config/vndk.go
347 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900348
349 // Used by vendor snapshot to record dependencies from snapshot modules.
350 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900351 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900352 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000353
Colin Cross1bc94122021-10-28 13:25:54 -0700354 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000355
356 // Set by factories of module types that can only be referenced from variants compiled against
357 // the SDK.
358 AlwaysSdk bool `blueprint:"mutated"`
359
360 // Variant is an SDK variant created by sdkMutator
361 IsSdkVariant bool `blueprint:"mutated"`
362 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
363 // variant to have a ".sdk" suffix.
364 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700365
366 // Normally Soong uses the directory structure to decide which modules
367 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800368 // different snapshots (vendor, recovery, etc.), but this property
369 // allows a partner to exclude a module normally thought of as a
370 // framework module from the vendor snapshot.
371 Exclude_from_vendor_snapshot *bool
372
373 // Normally Soong uses the directory structure to decide which modules
374 // should be included (framework) or excluded (non-framework) from the
375 // different snapshots (vendor, recovery, etc.), but this property
376 // allows a partner to exclude a module normally thought of as a
377 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800378 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900379
380 // List of APEXes that this module has private access to for testing purpose. The module
381 // can depend on libraries that are not exported by the APEXes and use private symbols
382 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000383 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800384
385 Target struct {
386 Platform struct {
387 // List of modules required by the core variant.
388 Required []string `android:"arch_variant"`
389
390 // List of modules not required by the core variant.
391 Exclude_required []string `android:"arch_variant"`
392 } `android:"arch_variant"`
393
394 Recovery struct {
395 // List of modules required by the recovery variant.
396 Required []string `android:"arch_variant"`
397
398 // List of modules not required by the recovery variant.
399 Exclude_required []string `android:"arch_variant"`
400 } `android:"arch_variant"`
401 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700402}
403
404type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900405 // whether this module should be allowed to be directly depended by other
406 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900407 // If set to true, two variants will be built separately, one like
408 // normal, and the other limited to the set of libraries and headers
409 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700410 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900411 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700412 // so it shouldn't have any unversioned runtime dependencies, or
413 // make assumptions about the system that may not be true in the
414 // future.
415 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900416 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900417 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900418 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900419 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900420 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700421 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
422 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900423
Justin Yunebcf0c52021-01-08 18:00:19 +0900424 // This is the same as the "vendor_available" except that the install path
425 // of the vendor variant is /odm or /vendor/odm.
426 // By replacing "vendor_available: true" with "odm_available: true", the
427 // module will install its vendor variant to the /odm partition or /vendor/odm.
428 // As the modules with "odm_available: true" still create the vendor variants,
429 // they can link to the other vendor modules as the vendor_available modules do.
430 // Also, the vendor modules can link to odm_available modules.
431 //
432 // It may not be used for VNDK modules.
433 Odm_available *bool
434
Justin Yun63e9ec72020-10-29 16:49:43 +0900435 // whether this module should be allowed to be directly depended by other
436 // modules with `product_specific: true` or `product_available: true`.
437 // If set to true, an additional product variant will be built separately
438 // that is limited to the set of libraries and headers that are exposed to
439 // /product modules.
440 //
441 // The product variant may be used with a different (newer) /system,
442 // so it shouldn't have any unversioned runtime dependencies, or
443 // make assumptions about the system that may not be true in the
444 // future.
445 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900446 // If set to false, this module becomes inaccessible from /product modules.
447 //
448 // Different from the 'vendor_available' property, the modules with
449 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
450 // library without 'product_available' may not be depended on by any other
451 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900452 //
453 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
454 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
455 Product_available *bool
456
Jiyong Park5fb8c102018-04-09 12:03:06 +0900457 // whether this module is capable of being loaded with other instance
458 // (possibly an older version) of the same module in the same process.
459 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
460 // can be double loaded in a vendor process if the library is also a
461 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
462 // explicitly marked as `double_loadable: true` by the owner, or the dependency
463 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
464 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800465
466 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
467 IsLLNDK bool `blueprint:"mutated"`
468
Colin Cross78212242021-01-06 14:51:30 -0800469 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
470 // set and the module is not listed in VndkMustUseVendorVariantList.
471 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
472
473 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
474 IsVNDKCore bool `blueprint:"mutated"`
475
476 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
477 IsVNDKSP bool `blueprint:"mutated"`
478
479 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
480 // module sets the llndk.private property.
481 IsVNDKPrivate bool `blueprint:"mutated"`
482
483 // IsVNDKProduct is set if a VNDK module sets the product_available property.
484 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700485
486 // IsVendorPublicLibrary is set for the core and product variants of a library that has
487 // vendor_public_library stubs.
488 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800489}
490
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500491// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
492// to understanding details about the type of the current module.
493// For example, one might call these functions to determine whether the current module is a static
494// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800495type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800496 static() bool
497 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700498 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800499 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900500 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900501 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900502 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700503 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900504 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700505 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800506 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900507 minSdkVersion() string
508 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700509 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700510 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800511 IsLlndk() bool
512 IsLlndkPublic() bool
513 isImplementationForLLNDKPublic() bool
514 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900515 isVndk() bool
516 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500517 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700518 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900519 inProduct() bool
520 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800521 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700522 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900523 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900524 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700525 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700526 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800527 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800528 isAfdoCompile() bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000529 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800530 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900531 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800532 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800533 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800534 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700535 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700536 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900537 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800538 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700539 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700540 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800541 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800542 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800543 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800544 notInPlatform() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800545}
546
547type SharedFlags struct {
548 numSharedFlags int
549 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800550}
551
552type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700553 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800554 ModuleContextIntf
555}
556
557type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700558 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800559 ModuleContextIntf
560}
561
Colin Cross37047f12016-12-13 17:06:13 -0800562type DepsContext interface {
563 android.BottomUpMutatorContext
564 ModuleContextIntf
565}
566
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500567// feature represents additional (optional) steps to building cc-related modules, such as invocation
568// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800569type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800570 flags(ctx ModuleContext, flags Flags) Flags
571 props() []interface{}
572}
573
Joe Onorato37f900c2023-07-18 16:58:16 -0700574// Information returned from Generator about the source code it's generating
575type GeneratedSource struct {
576 IncludeDirs android.Paths
577 Sources android.Paths
578 Headers android.Paths
579 ReexportedDirs android.Paths
580}
581
582// generator allows injection of generated code
583type Generator interface {
584 GeneratorProps() []interface{}
585 GeneratorInit(ctx BaseModuleContext)
586 GeneratorDeps(ctx DepsContext, deps Deps) Deps
587 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
588 GeneratorSources(ctx ModuleContext) GeneratedSource
589 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
590}
591
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500592// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500593// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800594type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700595 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800596 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800597 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700598 compilerProps() []interface{}
599
Colin Cross76fada02016-07-27 10:31:13 -0700600 appendCflags([]string)
601 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700602 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800603}
604
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500605// linker is the interface for a linker decorator object. Individual module types can provide
606// their own implementation for this decorator, and thus specify custom logic regarding build
607// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800608type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700609 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800610 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700611 linkerFlags(ctx ModuleContext, flags Flags) Flags
612 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800613 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700614
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700615 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700616 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900617 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800618 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700619
620 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900621 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000622
623 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000624 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800625
626 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000627}
628
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500629// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000630type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500631 sharedLibs []string
632 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
633 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700634 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800635}
636
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500637// installer is the interface for an installer helper object. This helper is responsible for
638// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800639type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700640 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700641 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000642 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800643 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700644 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700645 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900646 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000647 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900648 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800649}
650
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800651type xref interface {
652 XrefCcFiles() android.Paths
653}
654
Inseob Kima1888ce2022-10-04 14:42:02 +0900655type overridable interface {
656 overriddenModules() []string
657}
658
Colin Cross6e511a92020-07-27 21:26:48 -0700659type libraryDependencyKind int
660
661const (
662 headerLibraryDependency = iota
663 sharedLibraryDependency
664 staticLibraryDependency
665)
666
667func (k libraryDependencyKind) String() string {
668 switch k {
669 case headerLibraryDependency:
670 return "headerLibraryDependency"
671 case sharedLibraryDependency:
672 return "sharedLibraryDependency"
673 case staticLibraryDependency:
674 return "staticLibraryDependency"
675 default:
676 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
677 }
678}
679
680type libraryDependencyOrder int
681
682const (
683 earlyLibraryDependency = -1
684 normalLibraryDependency = 0
685 lateLibraryDependency = 1
686)
687
688func (o libraryDependencyOrder) String() string {
689 switch o {
690 case earlyLibraryDependency:
691 return "earlyLibraryDependency"
692 case normalLibraryDependency:
693 return "normalLibraryDependency"
694 case lateLibraryDependency:
695 return "lateLibraryDependency"
696 default:
697 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
698 }
699}
700
701// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
702// tags that have a set of predefined tag objects that are reused for each dependency, a
703// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
704// That means that comparing a libraryDependencyTag for equality will only be equal if all
705// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
706// then check individual metadata fields instead.
707type libraryDependencyTag struct {
708 blueprint.BaseDependencyTag
709
710 // These are exported so that fmt.Printf("%#v") can call their String methods.
711 Kind libraryDependencyKind
712 Order libraryDependencyOrder
713
714 wholeStatic bool
715
716 reexportFlags bool
717 explicitlyVersioned bool
718 dataLib bool
719 ndk bool
720
721 staticUnwinder bool
722
723 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900724
Cindy Zhou18417cb2020-12-10 07:12:38 -0800725 // Whether or not this dependency should skip the apex dependency check
726 skipApexAllowedDependenciesCheck bool
727
Jiyong Parke3867542020-12-03 17:28:25 +0900728 // Whether or not this dependency has to be followed for the apex variants
729 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900730 // Whether or not this dependency has to be followed for the non-apex variants
731 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000732
733 // If true, don't automatically export symbols from the static library into a shared library.
734 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700735}
736
737// header returns true if the libraryDependencyTag is tagging a header lib dependency.
738func (d libraryDependencyTag) header() bool {
739 return d.Kind == headerLibraryDependency
740}
741
742// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
743func (d libraryDependencyTag) shared() bool {
744 return d.Kind == sharedLibraryDependency
745}
746
747// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
748func (d libraryDependencyTag) static() bool {
749 return d.Kind == staticLibraryDependency
750}
751
Colin Cross65cb3142021-12-10 23:05:02 +0000752func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
753 if d.shared() {
754 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
755 }
756 return nil
757}
758
759var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
760
Colin Crosse9fe2942020-11-10 18:12:15 -0800761// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
762// binaries or other shared libraries are installed as dependencies.
763func (d libraryDependencyTag) InstallDepNeeded() bool {
764 return d.shared()
765}
766
767var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
768
769// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700770// libraryDependencyTag. Each tag object is created globally and reused for multiple
771// dependencies (although since the object contains no references, assigning a tag to a
772// variable and modifying it will not modify the original). Users can compare the tag
773// returned by ctx.OtherModuleDependencyTag against the global original
774type dependencyTag struct {
775 blueprint.BaseDependencyTag
776 name string
777}
778
Colin Crosse9fe2942020-11-10 18:12:15 -0800779// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
780// libraryDependencyTag, but where the dependency needs to be installed when the parent is
781// installed.
782type installDependencyTag struct {
783 blueprint.BaseDependencyTag
784 android.InstallAlwaysNeededDependencyTag
785 name string
786}
787
Colin Crossc99deeb2016-04-11 15:06:20 -0700788var (
Colin Cross6e511a92020-07-27 21:26:48 -0700789 genSourceDepTag = dependencyTag{name: "gen source"}
790 genHeaderDepTag = dependencyTag{name: "gen header"}
791 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
792 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900793 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700794 reuseObjTag = dependencyTag{name: "reuse objects"}
795 staticVariantTag = dependencyTag{name: "static variant"}
796 vndkExtDepTag = dependencyTag{name: "vndk extends"}
797 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700798 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800799 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700800 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700801 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000802 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500803 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400804 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700805)
806
Roland Levillainf89cd092019-07-29 16:22:59 +0100807func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700808 ccLibDepTag, ok := depTag.(libraryDependencyTag)
809 return ok && ccLibDepTag.shared()
810}
811
812func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
813 ccLibDepTag, ok := depTag.(libraryDependencyTag)
814 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100815}
816
Zach Johnson3df4e632020-11-06 11:56:27 -0800817func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
818 ccLibDepTag, ok := depTag.(libraryDependencyTag)
819 return ok && ccLibDepTag.header()
820}
821
Roland Levillainf89cd092019-07-29 16:22:59 +0100822func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800823 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100824}
825
826func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700827 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100828 return ok && ccDepTag == testPerSrcDepTag
829}
830
Colin Crossca860ac2016-01-04 14:34:37 -0800831// Module contains the properties and members used by all C/C++ module types, and implements
832// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500833// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
834// interface.
835//
836// To define a C/C++ related module, construct a new Module object and point its delegates to
837// type-specific structs. These delegates will be invoked to register module-specific build
838// statements which may be unique to the module type. For example, module.compiler.compile() should
839// be defined so as to register build statements which are responsible for compiling the module.
840//
841// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
842// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
843// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
844// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800845type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700846 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700847
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700848 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700849 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700850
Colin Crossca860ac2016-01-04 14:34:37 -0800851 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000852 hod android.HostOrDeviceSupported
853 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000854 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700855
Paul Duffina0843f62019-12-13 19:50:38 +0000856 // Allowable SdkMemberTypes of this module type.
857 sdkMemberTypes []android.SdkMemberType
858
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500859 // decorator delegates, initialize before calling Init
860 // these may contain module-specific implementations, and effectively allow for custom
861 // type-specific logic. These members may reference different objects or the same object.
862 // Functions of these decorators will be invoked to initialize and register type-specific
863 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800864 generators []Generator
865 compiler compiler
866 linker linker
867 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500868
Spandan Dase12d2522023-09-12 21:42:31 +0000869 features []feature
870 stl *stl
871 sanitize *sanitize
872 coverage *coverage
873 fuzzer *fuzzer
874 sabi *sabi
875 vndkdep *vndkdep
876 lto *lto
877 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000878 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800879
Colin Cross31076b32020-10-23 17:22:06 -0700880 library libraryInterface
881
Colin Cross635c3b02016-05-18 15:37:25 -0700882 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800883
Colin Crossb98c8b02016-07-29 13:44:28 -0700884 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700885
886 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800887
888 // Flags used to compile this module
889 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700890
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800891 // Shared flags among build rules of this module
892 sharedFlags SharedFlags
893
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800894 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700895 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900896
897 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800898 // Kythe (source file indexer) paths for this compilation module
899 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700900 // Object .o file output paths for this compilation module
901 objFiles android.Paths
902 // Tidy .tidy file output paths for this compilation module
903 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900904
905 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700906 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700907
908 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800909
910 // Aconfig files for all transitive deps. Also exposed via TransitiveDeclarationsInfo
Colin Crossd788b3e2023-11-28 13:14:56 -0800911 mergedAconfigFiles map[string]android.Paths
Colin Crossc472d572015-03-17 15:06:21 -0700912}
913
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200914func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400915 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
916 if b, ok := c.compiler.(*baseCompiler); ok {
917 hasAidl = b.hasSrcExt(".aidl")
918 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
919 hasProto = b.hasSrcExt(".proto")
920 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
921 hasSysprop = b.hasSrcExt(".sysprop")
922 hasWinMsg = b.hasSrcExt(".mc")
923 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
924 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200925 c.AndroidModuleBase().AddJSONData(d)
926 (*d)["Cc"] = map[string]interface{}{
927 "SdkVersion": c.SdkVersion(),
928 "MinSdkVersion": c.MinSdkVersion(),
929 "VndkVersion": c.VndkVersion(),
930 "ProductSpecific": c.ProductSpecific(),
931 "SocSpecific": c.SocSpecific(),
932 "DeviceSpecific": c.DeviceSpecific(),
933 "InProduct": c.InProduct(),
934 "InVendor": c.InVendor(),
935 "InRamdisk": c.InRamdisk(),
936 "InVendorRamdisk": c.InVendorRamdisk(),
937 "InRecovery": c.InRecovery(),
938 "VendorAvailable": c.VendorAvailable(),
939 "ProductAvailable": c.ProductAvailable(),
940 "RamdiskAvailable": c.RamdiskAvailable(),
941 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
942 "RecoveryAvailable": c.RecoveryAvailable(),
943 "OdmAvailable": c.OdmAvailable(),
944 "InstallInData": c.InstallInData(),
945 "InstallInRamdisk": c.InstallInRamdisk(),
946 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
947 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
948 "InstallInRecovery": c.InstallInRecovery(),
949 "InstallInRoot": c.InstallInRoot(),
950 "IsVndk": c.IsVndk(),
951 "IsVndkExt": c.IsVndkExt(),
952 "IsVndkPrivate": c.IsVndkPrivate(),
953 "IsVndkSp": c.IsVndkSp(),
954 "IsLlndk": c.IsLlndk(),
955 "IsLlndkPublic": c.IsLlndkPublic(),
956 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
957 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
958 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
959 "ApexSdkVersion": c.apexSdkVersion,
960 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400961 "AidlSrcs": hasAidl,
962 "LexSrcs": hasLex,
963 "ProtoSrcs": hasProto,
964 "RenderscriptSrcs": hasRenderscript,
965 "SyspropSrcs": hasSysprop,
966 "WinMsgSrcs": hasWinMsg,
967 "YaccSrsc": hasYacc,
968 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200969 }
970}
971
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500972func (c *Module) SetPreventInstall() {
973 c.Properties.PreventInstall = true
974}
975
976func (c *Module) SetHideFromMake() {
977 c.Properties.HideFromMake = true
978}
979
Ivan Lozanod7586b62021-04-01 09:49:36 -0400980func (c *Module) HiddenFromMake() bool {
981 return c.Properties.HideFromMake
982}
983
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800984func (c *Module) RequiredModuleNames() []string {
985 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
986 if c.ImageVariation().Variation == android.CoreVariation {
987 required = append(required, c.Properties.Target.Platform.Required...)
988 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
989 } else if c.InRecovery() {
990 required = append(required, c.Properties.Target.Recovery.Required...)
991 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
992 }
993 return android.FirstUniqueStrings(required)
994}
995
Ivan Lozano52767be2019-10-18 14:49:46 -0700996func (c *Module) Toc() android.OptionalPath {
997 if c.linker != nil {
998 if library, ok := c.linker.(libraryInterface); ok {
999 return library.toc()
1000 }
1001 }
1002 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
1003}
1004
1005func (c *Module) ApiLevel() string {
1006 if c.linker != nil {
1007 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001008 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001009 }
1010 }
1011 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1012}
1013
1014func (c *Module) Static() bool {
1015 if c.linker != nil {
1016 if library, ok := c.linker.(libraryInterface); ok {
1017 return library.static()
1018 }
1019 }
1020 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1021}
1022
1023func (c *Module) Shared() bool {
1024 if c.linker != nil {
1025 if library, ok := c.linker.(libraryInterface); ok {
1026 return library.shared()
1027 }
1028 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001029
Ivan Lozano52767be2019-10-18 14:49:46 -07001030 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1031}
1032
1033func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001034 if c.stl != nil {
1035 return c.stl.Properties.SelectedStl
1036 }
1037 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001038}
1039
Ivan Lozano52767be2019-10-18 14:49:46 -07001040func (c *Module) NdkPrebuiltStl() bool {
1041 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1042 return true
1043 }
1044 return false
1045}
1046
1047func (c *Module) StubDecorator() bool {
1048 if _, ok := c.linker.(*stubDecorator); ok {
1049 return true
1050 }
1051 return false
1052}
1053
1054func (c *Module) SdkVersion() string {
1055 return String(c.Properties.Sdk_version)
1056}
1057
Artur Satayev480e25b2020-04-27 18:53:18 +01001058func (c *Module) MinSdkVersion() string {
1059 return String(c.Properties.Min_sdk_version)
1060}
1061
Jiyong Park5df7bd32021-08-25 16:18:46 +09001062func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001063 if linker, ok := c.linker.(*objectLinker); ok {
1064 return linker.isCrt()
1065 }
1066 return false
1067}
1068
Jiyong Park5df7bd32021-08-25 16:18:46 +09001069func (c *Module) SplitPerApiLevel() bool {
1070 return c.canUseSdk() && c.isCrt()
1071}
1072
Colin Crossc511bc52020-04-07 16:50:32 +00001073func (c *Module) AlwaysSdk() bool {
1074 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1075}
1076
Ivan Lozano183a3212019-10-18 14:18:45 -07001077func (c *Module) CcLibrary() bool {
1078 if c.linker != nil {
1079 if _, ok := c.linker.(*libraryDecorator); ok {
1080 return true
1081 }
Colin Crossd48fe732020-09-23 20:37:24 -07001082 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1083 return true
1084 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001085 }
1086 return false
1087}
1088
1089func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001090 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001091 return true
1092 }
1093 return false
1094}
1095
Spandan Dase12d2522023-09-12 21:42:31 +00001096func (c *Module) IsNdkPrebuiltStl() bool {
1097 if c.linker == nil {
1098 return false
1099 }
1100 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1101 return true
1102 }
1103 return false
1104}
1105
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001106func (c *Module) RlibStd() bool {
1107 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1108}
1109
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001110func (c *Module) RustLibraryInterface() bool {
1111 return false
1112}
1113
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001114func (c *Module) IsFuzzModule() bool {
1115 if _, ok := c.compiler.(*fuzzBinary); ok {
1116 return true
1117 }
1118 return false
1119}
1120
1121func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1122 return c.FuzzModule
1123}
1124
1125func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1126 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1127 return fuzzer.fuzzPackagedModule
1128 }
1129 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1130}
1131
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001132func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001133 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1134 return fuzzer.sharedLibraries
1135 }
1136 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1137}
1138
Ivan Lozano2b262972019-11-21 12:30:50 -08001139func (c *Module) NonCcVariants() bool {
1140 return false
1141}
1142
Ivan Lozano183a3212019-10-18 14:18:45 -07001143func (c *Module) SetStatic() {
1144 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001145 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001146 library.setStatic()
1147 return
1148 }
1149 }
1150 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1151}
1152
1153func (c *Module) SetShared() {
1154 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001155 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001156 library.setShared()
1157 return
1158 }
1159 }
1160 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1161}
1162
1163func (c *Module) BuildStaticVariant() bool {
1164 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001165 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001166 return library.buildStatic()
1167 }
1168 }
1169 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1170}
1171
1172func (c *Module) BuildSharedVariant() bool {
1173 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001174 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001175 return library.buildShared()
1176 }
1177 }
1178 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1179}
1180
1181func (c *Module) Module() android.Module {
1182 return c
1183}
1184
Jiyong Parkc20eee32018-09-05 22:36:17 +09001185func (c *Module) OutputFile() android.OptionalPath {
1186 return c.outputFile
1187}
1188
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001189func (c *Module) CoverageFiles() android.Paths {
1190 if c.linker != nil {
1191 if library, ok := c.linker.(libraryInterface); ok {
1192 return library.objs().coverageFiles
1193 }
1194 }
1195 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1196}
1197
Ivan Lozano183a3212019-10-18 14:18:45 -07001198var _ LinkableInterface = (*Module)(nil)
1199
Jiyong Park719b4462019-01-13 00:39:51 +09001200func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001201 if c.linker != nil {
1202 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001203 }
1204 return nil
1205}
1206
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001207func (c *Module) CoverageOutputFile() android.OptionalPath {
1208 if c.linker != nil {
1209 return c.linker.coverageOutputFilePath()
1210 }
1211 return android.OptionalPath{}
1212}
1213
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001214func (c *Module) RelativeInstallPath() string {
1215 if c.installer != nil {
1216 return c.installer.relativeInstallPath()
1217 }
1218 return ""
1219}
1220
Jooyung Han344d5432019-08-23 11:17:39 +09001221func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001222 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001223}
1224
Colin Cross36242852017-06-23 15:06:31 -07001225func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001226 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001227 for _, generator := range c.generators {
1228 c.AddProperties(generator.GeneratorProps()...)
1229 }
Colin Crossca860ac2016-01-04 14:34:37 -08001230 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001231 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001232 }
1233 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001234 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001235 }
1236 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001237 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001238 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001239 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001240 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001241 }
Colin Cross16b23492016-01-06 14:41:07 -08001242 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001243 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001244 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001245 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001246 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001247 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001248 if c.fuzzer != nil {
1249 c.AddProperties(c.fuzzer.props()...)
1250 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001251 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001252 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001253 }
Justin Yun8effde42017-06-23 19:24:43 +09001254 if c.vndkdep != nil {
1255 c.AddProperties(c.vndkdep.props()...)
1256 }
Stephen Craneba090d12017-05-09 15:44:35 -07001257 if c.lto != nil {
1258 c.AddProperties(c.lto.props()...)
1259 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001260 if c.afdo != nil {
1261 c.AddProperties(c.afdo.props()...)
1262 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001263 if c.orderfile != nil {
1264 c.AddProperties(c.orderfile.props()...)
1265 }
Colin Crossca860ac2016-01-04 14:34:37 -08001266 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001267 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001268 }
Colin Crossc472d572015-03-17 15:06:21 -07001269
Colin Cross36242852017-06-23 15:06:31 -07001270 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001271 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001272 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001273
Colin Cross36242852017-06-23 15:06:31 -07001274 return c
Colin Crossc472d572015-03-17 15:06:21 -07001275}
1276
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001277// UseVndk() returns true if this module is built against VNDK.
1278// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001279func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001280 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001281}
1282
Colin Crossc511bc52020-04-07 16:50:32 +00001283func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001284 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001285 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001286}
1287
1288func (c *Module) UseSdk() bool {
1289 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001290 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001291 }
1292 return false
1293}
1294
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001295func (c *Module) isCoverageVariant() bool {
1296 return c.coverage.Properties.IsCoverageVariant
1297}
1298
Colin Cross95f1ca02020-10-29 20:47:22 -07001299func (c *Module) IsNdk(config android.Config) bool {
1300 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001301}
1302
Colin Cross127bb8b2020-12-16 16:46:01 -08001303func (c *Module) IsLlndk() bool {
1304 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001305}
1306
Colin Cross127bb8b2020-12-16 16:46:01 -08001307func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001308 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001309}
1310
Colin Cross1f3f1302021-04-26 18:37:44 -07001311func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001312 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001313 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001314}
1315
Colin Cross5271fea2021-04-27 13:06:04 -07001316func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1317 lib := moduleLibraryInterface(m)
1318 return lib != nil && (lib.hasVendorPublicLibrary())
1319}
1320
1321// IsVendorPublicLibrary returns true for vendor public libraries.
1322func (c *Module) IsVendorPublicLibrary() bool {
1323 return c.VendorProperties.IsVendorPublicLibrary
1324}
1325
Ivan Lozanof1868af2022-04-12 13:08:36 -04001326func (c *Module) IsVndkPrebuiltLibrary() bool {
1327 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1328 return true
1329 }
1330 return false
1331}
1332
1333func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1334 return c.Properties.SdkAndPlatformVariantVisibleToMake
1335}
1336
Ivan Lozanod7586b62021-04-01 09:49:36 -04001337func (c *Module) HasLlndkStubs() bool {
1338 lib := moduleLibraryInterface(c)
1339 return lib != nil && lib.hasLLNDKStubs()
1340}
1341
1342func (c *Module) StubsVersion() string {
1343 if lib, ok := c.linker.(versionedInterface); ok {
1344 return lib.stubsVersion()
1345 }
1346 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1347}
1348
Colin Cross127bb8b2020-12-16 16:46:01 -08001349// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1350// and does not set llndk.vendor_available: false.
1351func (c *Module) isImplementationForLLNDKPublic() bool {
1352 library, _ := c.library.(*libraryDecorator)
1353 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001354 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001355}
1356
Justin Yunfd9e8042020-12-23 18:23:14 +09001357// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001358func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001359 // Check if VNDK-core-private or VNDK-SP-private
1360 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001361 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001362 }
1363
1364 // Check if LLNDK-private
1365 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001366 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001367 }
1368
1369 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001370}
1371
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001372// IsVndk() returns true if this module has a vndk variant.
1373// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1374// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001375func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001376 if vndkdep := c.vndkdep; vndkdep != nil {
1377 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001378 }
1379 return false
1380}
1381
Yi Kong4ef54592022-02-14 20:00:10 +08001382func (c *Module) isAfdoCompile() bool {
1383 if afdo := c.afdo; afdo != nil {
Colin Cross943aa5c2024-01-24 14:44:47 -08001384 return afdo.Properties.Afdo || afdo.Properties.AfdoDep
Yi Kong4ef54592022-02-14 20:00:10 +08001385 }
1386 return false
1387}
1388
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001389func (c *Module) isOrderfileCompile() bool {
1390 if orderfile := c.orderfile; orderfile != nil {
1391 return orderfile.Properties.OrderfileLoad
1392 }
1393 return false
1394}
1395
Yi Kongc702ebd2022-08-19 16:02:45 +08001396func (c *Module) isCfi() bool {
1397 if sanitize := c.sanitize; sanitize != nil {
Yi Kongddffe722023-07-18 16:40:36 +09001398 return Bool(sanitize.Properties.SanitizeMutated.Cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001399 }
1400 return false
1401}
1402
Yi Konged79fa32023-06-04 17:15:42 +09001403func (c *Module) isFuzzer() bool {
1404 if sanitize := c.sanitize; sanitize != nil {
1405 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1406 }
1407 return false
1408}
1409
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001410func (c *Module) isNDKStubLibrary() bool {
1411 if _, ok := c.compiler.(*stubDecorator); ok {
1412 return true
1413 }
1414 return false
1415}
1416
Ivan Lozanod7586b62021-04-01 09:49:36 -04001417func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001418 if vndkdep := c.vndkdep; vndkdep != nil {
1419 return vndkdep.isVndkSp()
1420 }
1421 return false
1422}
1423
Ivan Lozanof9e21722020-12-02 09:00:51 -05001424func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001425 if vndkdep := c.vndkdep; vndkdep != nil {
1426 return vndkdep.isVndkExt()
1427 }
1428 return false
1429}
1430
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001431func (c *Module) SubName() string {
1432 return c.Properties.SubName
1433}
1434
Ivan Lozano52767be2019-10-18 14:49:46 -07001435func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001436 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001437}
1438
Logan Chienf3511742017-10-31 18:04:35 +08001439func (c *Module) getVndkExtendsModuleName() string {
1440 if vndkdep := c.vndkdep; vndkdep != nil {
1441 return vndkdep.getVndkExtendsModuleName()
1442 }
1443 return ""
1444}
1445
Jiyong Park25fc6a92018-11-18 18:02:45 +09001446func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001447 if lib := c.library; lib != nil {
1448 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001449 }
1450 return false
1451}
1452
1453func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001454 if lib := c.library; lib != nil {
1455 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001456 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001457 return false
1458}
1459
Alan Stokes73feba32022-11-14 12:21:24 +00001460func (c *Module) IsStubsImplementationRequired() bool {
1461 if lib := c.library; lib != nil {
1462 return lib.isStubsImplementationRequired()
1463 }
1464 return false
1465}
1466
Colin Cross0477b422020-10-13 18:43:54 -07001467// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1468// the implementation. If it is an implementation library it returns its own name.
1469func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1470 name := ctx.OtherModuleName(c)
1471 if versioned, ok := c.linker.(versionedInterface); ok {
1472 name = versioned.implementationModuleName(name)
1473 }
1474 return name
1475}
1476
Martin Stjernholm2856c662020-12-02 15:03:42 +00001477// Similar to ImplementationModuleName, but uses the Make variant of the module
1478// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1479// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1480// under the premise that the prebuilt module overrides its source counterpart
1481// if it is exposed to Make).
1482func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1483 name := c.BaseModuleName()
1484 if versioned, ok := c.linker.(versionedInterface); ok {
1485 name = versioned.implementationModuleName(name)
1486 }
1487 return name
1488}
1489
Jiyong Park7d55b612021-06-11 17:22:09 +09001490func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001491 return Bool(c.Properties.Bootstrap)
1492}
1493
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001494func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001495 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1496 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1497 return false
1498 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001499 return c.linker != nil && c.linker.nativeCoverage()
1500}
1501
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001502func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001503 if p, ok := c.linker.(SnapshotInterface); ok {
1504 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001505 }
1506 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001507}
1508
Bill Peckham945441c2020-08-31 16:07:58 -07001509func (c *Module) ExcludeFromVendorSnapshot() bool {
1510 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1511}
1512
Jose Galmesf7294582020-11-13 12:07:36 -08001513func (c *Module) ExcludeFromRecoverySnapshot() bool {
1514 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1515}
1516
Jiyong Parkf1194352019-02-25 11:05:47 +09001517func isBionic(name string) bool {
1518 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001519 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001520 return true
1521 }
1522 return false
1523}
1524
Martin Stjernholm279de572019-09-10 23:18:20 +01001525func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001526 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001527 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001528 }
1529 return isBionic(name)
1530}
1531
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001532func (c *Module) XrefCcFiles() android.Paths {
1533 return c.kytheFiles
1534}
1535
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001536func (c *Module) isCfiAssemblySupportEnabled() bool {
1537 return c.sanitize != nil &&
1538 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1539}
1540
Inseob Kim800d1142021-06-14 12:03:51 +09001541func (c *Module) InstallInRoot() bool {
1542 return c.installer != nil && c.installer.installInRoot()
1543}
1544
Colin Crossca860ac2016-01-04 14:34:37 -08001545type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001546 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001547 moduleContextImpl
1548}
1549
Colin Cross37047f12016-12-13 17:06:13 -08001550type depsContext struct {
1551 android.BottomUpMutatorContext
1552 moduleContextImpl
1553}
1554
Colin Crossca860ac2016-01-04 14:34:37 -08001555type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001556 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001557 moduleContextImpl
1558}
1559
1560type moduleContextImpl struct {
1561 mod *Module
1562 ctx BaseModuleContext
1563}
1564
Colin Crossb98c8b02016-07-29 13:44:28 -07001565func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001566 return ctx.mod.toolchain(ctx.ctx)
1567}
1568
1569func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001570 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001571}
1572
1573func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001574 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001575}
1576
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001577func (ctx *moduleContextImpl) testBinary() bool {
1578 return ctx.mod.testBinary()
1579}
1580
Yi Kong56fc1b62022-09-06 16:24:00 +08001581func (ctx *moduleContextImpl) testLibrary() bool {
1582 return ctx.mod.testLibrary()
1583}
1584
Jiyong Park1d1119f2019-07-29 21:27:18 +09001585func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001586 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001587}
1588
Inseob Kim7f283f42020-06-01 21:53:49 +09001589func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001590 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001591}
1592
Inseob Kim1042d292020-06-01 23:23:05 +09001593func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001594 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001595}
1596
Jooyung Hanccce2f22020-03-07 03:45:53 +09001597func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001598 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001599}
1600
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001601func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001602 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001603}
1604
1605func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001606 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001607 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001608 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001609 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001610 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001611 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001612 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001613 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001614 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001615 }
1616 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001617}
1618
Jiyong Parkb35a8192020-08-10 15:59:36 +09001619func (ctx *moduleContextImpl) minSdkVersion() string {
1620 ver := ctx.mod.MinSdkVersion()
1621 if ver == "apex_inherit" && !ctx.isForPlatform() {
1622 ver = ctx.apexSdkVersion().String()
1623 }
1624 if ver == "apex_inherit" || ver == "" {
1625 ver = ctx.sdkVersion()
1626 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001627 // For crt objects, the meaning of min_sdk_version is very different from other types of
1628 // module. For them, min_sdk_version defines the oldest version that the build system will
1629 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1630 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1631 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001632 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1633 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1634 // support such an old version. The version is set to the later version in case when the
1635 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1636 // it's for an APEX.
1637 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1638 if ctx.isForPlatform() {
1639 ver = strconv.Itoa(android.FutureApiLevelInt)
1640 } else { // for apex
1641 ver = ctx.apexSdkVersion().String()
1642 if ver == "" { // in case when min_sdk_version was not set by the APEX
1643 ver = ctx.sdkVersion()
1644 }
1645 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001646 }
1647
Jiyong Parkb35a8192020-08-10 15:59:36 +09001648 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1649 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1650 minSdkVersionInt, err2 := strconv.Atoi(ver)
1651 if err == nil && err2 == nil {
1652 if sdkVersionInt < minSdkVersionInt {
1653 return strconv.Itoa(sdkVersionInt)
1654 }
1655 }
1656 return ver
1657}
1658
1659func (ctx *moduleContextImpl) isSdkVariant() bool {
1660 return ctx.mod.IsSdkVariant()
1661}
1662
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001663func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001664 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001665}
Justin Yun8effde42017-06-23 19:24:43 +09001666
Kiyoung Kimaa394802024-01-08 12:55:45 +09001667func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1668 return ctx.mod.InVendorOrProduct()
1669}
1670
Colin Cross95f1ca02020-10-29 20:47:22 -07001671func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1672 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001673}
1674
Colin Cross127bb8b2020-12-16 16:46:01 -08001675func (ctx *moduleContextImpl) IsLlndk() bool {
1676 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001677}
1678
Colin Cross127bb8b2020-12-16 16:46:01 -08001679func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1680 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001681}
1682
Colin Cross127bb8b2020-12-16 16:46:01 -08001683func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1684 return ctx.mod.isImplementationForLLNDKPublic()
1685}
1686
1687func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1688 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001689}
1690
Logan Chienf3511742017-10-31 18:04:35 +08001691func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001692 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001693}
1694
Yi Kong4ef54592022-02-14 20:00:10 +08001695func (ctx *moduleContextImpl) isAfdoCompile() bool {
1696 return ctx.mod.isAfdoCompile()
1697}
1698
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001699func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1700 return ctx.mod.isOrderfileCompile()
1701}
1702
Yi Kongc702ebd2022-08-19 16:02:45 +08001703func (ctx *moduleContextImpl) isCfi() bool {
1704 return ctx.mod.isCfi()
1705}
1706
Yi Konged79fa32023-06-04 17:15:42 +09001707func (ctx *moduleContextImpl) isFuzzer() bool {
1708 return ctx.mod.isFuzzer()
1709}
1710
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001711func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1712 return ctx.mod.isNDKStubLibrary()
1713}
1714
Justin Yun8effde42017-06-23 19:24:43 +09001715func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001716 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001717}
1718
Ivan Lozanof9e21722020-12-02 09:00:51 -05001719func (ctx *moduleContextImpl) IsVndkExt() bool {
1720 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001721}
1722
Colin Cross5271fea2021-04-27 13:06:04 -07001723func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1724 return ctx.mod.IsVendorPublicLibrary()
1725}
1726
Vic Yangefd249e2018-11-12 20:19:56 -08001727func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001728 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001729}
1730
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001731func (ctx *moduleContextImpl) selectedStl() string {
1732 if stl := ctx.mod.stl; stl != nil {
1733 return stl.Properties.SelectedStl
1734 }
1735 return ""
1736}
1737
Ivan Lozanobd721262018-11-27 14:33:03 -08001738func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1739 return ctx.mod.linker.useClangLld(actx)
1740}
1741
Colin Crossce75d2c2016-10-06 16:12:58 -07001742func (ctx *moduleContextImpl) baseModuleName() string {
1743 return ctx.mod.ModuleBase.BaseModuleName()
1744}
1745
Logan Chienf3511742017-10-31 18:04:35 +08001746func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1747 return ctx.mod.getVndkExtendsModuleName()
1748}
1749
Logan Chiene274fc92019-12-03 11:18:32 -08001750func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001751 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1752 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001753}
1754
Colin Crosse07f2312020-08-13 11:24:56 -07001755func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001756 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1757 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001758}
1759
Dan Albertc8060532020-07-22 22:32:17 -07001760func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001761 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001762}
1763
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001764func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001765 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001766}
1767
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001768func (ctx *moduleContextImpl) nativeCoverage() bool {
1769 return ctx.mod.nativeCoverage()
1770}
1771
Colin Cross56a83212020-09-15 18:30:11 -07001772func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1773 return ctx.mod.DirectlyInAnyApex()
1774}
1775
Colin Cross95b07f22020-12-16 11:06:50 -08001776func (ctx *moduleContextImpl) isPreventInstall() bool {
1777 return ctx.mod.Properties.PreventInstall
1778}
1779
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001780func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1781 shared := &ctx.mod.sharedFlags
1782 if shared.flagsMap == nil {
1783 shared.numSharedFlags = 0
1784 shared.flagsMap = make(map[string]string)
1785 }
1786 return shared
1787}
1788
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001789func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1790 return ctx.mod.isCfiAssemblySupportEnabled()
1791}
1792
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001793func (ctx *moduleContextImpl) notInPlatform() bool {
1794 return ctx.mod.NotInPlatform()
1795}
1796
Colin Cross635c3b02016-05-18 15:37:25 -07001797func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001798 return &Module{
1799 hod: hod,
1800 multilib: multilib,
1801 }
1802}
1803
Colin Cross635c3b02016-05-18 15:37:25 -07001804func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001805 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001806 module.features = []feature{
1807 &tidyFeature{},
1808 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001809 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001810 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001811 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001812 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001813 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001814 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001815 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001816 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001817 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001818 return module
1819}
1820
Colin Crossce75d2c2016-10-06 16:12:58 -07001821func (c *Module) Prebuilt() *android.Prebuilt {
1822 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1823 return p.prebuilt()
1824 }
1825 return nil
1826}
1827
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001828func (c *Module) IsPrebuilt() bool {
1829 return c.Prebuilt() != nil
1830}
1831
Colin Crossce75d2c2016-10-06 16:12:58 -07001832func (c *Module) Name() string {
1833 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001834 if p, ok := c.linker.(interface {
1835 Name(string) string
1836 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001837 name = p.Name(name)
1838 }
1839 return name
1840}
1841
Alex Light3d673592019-01-18 14:37:31 -08001842func (c *Module) Symlinks() []string {
1843 if p, ok := c.installer.(interface {
1844 symlinkList() []string
1845 }); ok {
1846 return p.symlinkList()
1847 }
1848 return nil
1849}
1850
Roland Levillainf89cd092019-07-29 16:22:59 +01001851func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1852 test, ok := c.linker.(testPerSrc)
1853 return ok && test.isAllTestsVariation()
1854}
1855
Chris Parsons216e10a2020-07-09 17:12:52 -04001856func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001857 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001858 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001859 }); ok {
1860 return p.dataPaths()
1861 }
1862 return nil
1863}
1864
Ivan Lozanof1868af2022-04-12 13:08:36 -04001865func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001866 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1867 // "current", it will append the VNDK version to the name suffix.
1868 var vndkVersion string
1869 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001870 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001871 if c.ProductSpecific() {
1872 // If the module is product specific with 'product_specific: true',
1873 // do not add a name suffix because it is a base module.
1874 return ""
1875 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001876 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001877 } else {
1878 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001879 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001880 }
1881 if vndkVersion == "current" {
1882 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1883 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001884 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001885 // add version suffix only if the module is using different vndk version than the
1886 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001887 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001888 }
1889 return nameSuffix
1890}
1891
Ivan Lozanof1868af2022-04-12 13:08:36 -04001892func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1893 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001894
1895 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001896 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001897 }
1898
Colin Cross127bb8b2020-12-16 16:46:01 -08001899 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001900 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001901 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1902 // added for product variant only when we have vendor and product variants with core
1903 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001904 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001905 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001906 subName += vendorPublicLibrarySuffix
1907 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001908 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1909 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001910 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001911 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001912 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001913 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001914 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001915 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001916 subName += RecoverySuffix
1917 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1918 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001919 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001920 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001921 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001922 } else if c.IsStubs() && c.IsSdkVariant() {
1923 // Public API surface (NDK)
1924 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1925 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001926 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001927
1928 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001929}
1930
Sam Delmerico75dbca22023-04-20 13:13:25 +00001931func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1932 ctx := &moduleContext{
1933 ModuleContext: actx,
1934 moduleContextImpl: moduleContextImpl{
1935 mod: c,
1936 },
1937 }
1938 ctx.ctx = ctx
1939 return ctx
1940}
1941
Spandan Das20fce2d2023-04-12 17:21:39 +00001942// TODO (b/277651159): Remove this allowlist
1943var (
1944 skipStubLibraryMultipleApexViolation = map[string]bool{
1945 "libclang_rt.asan": true,
1946 "libclang_rt.hwasan": true,
1947 // runtime apex
1948 "libc": true,
1949 "libc_hwasan": true,
1950 "libdl_android": true,
1951 "libm": true,
1952 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001953 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001954 // art apex
1955 "libandroidio": true,
1956 "libdexfile": true,
1957 "libnativebridge": true,
1958 "libnativehelper": true,
1959 "libnativeloader": true,
1960 "libsigchain": true,
1961 }
1962)
1963
1964// Returns true if a stub library could be installed in multiple apexes
1965func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1966 // If this is not an apex variant, no check necessary
1967 if !c.InAnyApex() {
1968 return false
1969 }
1970 // If this is not a stub library, no check necessary
1971 if !c.HasStubsVariants() {
1972 return false
1973 }
1974 // Skip the allowlist
1975 // Use BaseModuleName so that this matches prebuilts.
1976 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1977 return false
1978 }
1979
1980 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1981 // Stub libraries should not have more than one apex_available
1982 if len(aaWithoutTestApexes) > 1 {
1983 return true
1984 }
1985 // Stub libraries should not use the wildcard
1986 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1987 return true
1988 }
1989 // Default: no violation
1990 return false
1991}
1992
LaMont Jonesafe7baf2024-01-09 22:47:39 +00001993func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1994 android.CollectDependencyAconfigFiles(ctx, &d.mergedAconfigFiles)
1995}
1996
Chris Parsons8d6e4332021-02-22 16:13:50 -05001997func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001998 // Handle the case of a test module split by `test_per_src` mutator.
1999 //
2000 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
2001 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
2002 // module and return early, as this module does not produce an output file per se.
2003 if c.IsTestPerSrcAllTestsVariation() {
2004 c.outputFile = android.OptionalPath{}
2005 return
2006 }
2007
Ivan Lozanof1868af2022-04-12 13:08:36 -04002008 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08002009 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002010 if !apexInfo.IsForPlatform() {
2011 c.hideApexVariantFromMake = true
2012 }
2013
Chris Parsonseefc9e62021-04-02 17:36:47 -04002014 c.makeLinkType = GetMakeLinkType(actx, c)
2015
Sam Delmerico75dbca22023-04-20 13:13:25 +00002016 ctx := moduleContextFromAndroidModuleContext(actx, c)
Colin Crossca860ac2016-01-04 14:34:37 -08002017
Colin Crossf18e1102017-11-16 14:33:08 -08002018 deps := c.depsToPaths(ctx)
2019 if ctx.Failed() {
2020 return
2021 }
2022
Joe Onorato37f900c2023-07-18 16:58:16 -07002023 for _, generator := range c.generators {
2024 gen := generator.GeneratorSources(ctx)
2025 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
2026 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
2027 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
2028 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
2029 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
2030 if len(deps.Objs.objFiles) == 0 {
2031 // If we are reusuing object files (which happens when we're a shared library and we're
2032 // reusing our static variant's object files), then skip adding the actual source files,
2033 // because we already have the object for it.
2034 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
2035 }
2036 }
2037
2038 if ctx.Failed() {
2039 return
2040 }
2041
Spandan Das20fce2d2023-04-12 17:21:39 +00002042 if c.stubLibraryMultipleApexViolation(actx) {
2043 actx.PropertyErrorf("apex_available",
2044 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
2045 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002046 if c.Properties.Clang != nil && *c.Properties.Clang == false {
2047 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00002048 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
2049 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002050 }
2051
Colin Crossca860ac2016-01-04 14:34:37 -08002052 flags := Flags{
2053 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002054 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002055 }
Joe Onorato37f900c2023-07-18 16:58:16 -07002056 for _, generator := range c.generators {
2057 flags = generator.GeneratorFlags(ctx, flags, deps)
2058 }
Colin Crossca860ac2016-01-04 14:34:37 -08002059 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002060 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002061 }
2062 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002063 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002064 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002065 if c.stl != nil {
2066 flags = c.stl.flags(ctx, flags)
2067 }
Colin Cross16b23492016-01-06 14:41:07 -08002068 if c.sanitize != nil {
2069 flags = c.sanitize.flags(ctx, flags)
2070 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002071 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002072 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002073 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002074 if c.fuzzer != nil {
2075 flags = c.fuzzer.flags(ctx, flags)
2076 }
Stephen Craneba090d12017-05-09 15:44:35 -07002077 if c.lto != nil {
2078 flags = c.lto.flags(ctx, flags)
2079 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002080 if c.afdo != nil {
2081 flags = c.afdo.flags(ctx, flags)
2082 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002083 if c.orderfile != nil {
2084 flags = c.orderfile.flags(ctx, flags)
2085 }
Colin Crossca860ac2016-01-04 14:34:37 -08002086 for _, feature := range c.features {
2087 flags = feature.flags(ctx, flags)
2088 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002089 if ctx.Failed() {
2090 return
2091 }
2092
Colin Cross4af21ed2019-11-04 09:37:55 -08002093 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2094 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2095 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002096
Colin Cross4af21ed2019-11-04 09:37:55 -08002097 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002098
2099 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002100 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002101 }
2102 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002103 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002104 }
2105
Colin Cross3e5e7782022-06-17 22:17:05 +00002106 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2107
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002108 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002109 // We need access to all the flags seen by a source file.
2110 if c.sabi != nil {
2111 flags = c.sabi.flags(ctx, flags)
2112 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002113
Colin Cross4af21ed2019-11-04 09:37:55 -08002114 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002115
Joe Onorato37f900c2023-07-18 16:58:16 -07002116 for _, generator := range c.generators {
2117 generator.GeneratorBuildActions(ctx, flags, deps)
2118 }
2119
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002120 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002121 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002122 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002123 if ctx.Failed() {
2124 return
2125 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002126 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002127 c.objFiles = objs.objFiles
2128 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002129 }
2130
Colin Crossca860ac2016-01-04 14:34:37 -08002131 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002132 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002133 if ctx.Failed() {
2134 return
2135 }
Colin Cross635c3b02016-05-18 15:37:25 -07002136 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002137
Chris Parsons94a0bba2021-06-04 15:03:47 -04002138 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002139
Jose Galmes6f843bc2020-12-11 13:36:29 -08002140 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2141 // RECOVERY_SNAPSHOT_VERSION is current.
2142 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002143 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002144 i.collectHeadersForSnapshot(ctx)
2145 }
2146 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002147 }
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002148 if c.testModule {
Colin Cross40213022023-12-13 15:19:49 -08002149 android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{})
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002150 }
Colin Cross40213022023-12-13 15:19:49 -08002151 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002152
LaMont Jonesaa005ae2023-12-19 19:01:57 +00002153 android.CollectDependencyAconfigFiles(ctx, &c.mergedAconfigFiles)
Yu Liueae7b362023-11-16 17:05:47 -08002154
Chris Parsons94a0bba2021-06-04 15:03:47 -04002155 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002156
2157 if c.linker != nil {
2158 moduleInfoJSON := ctx.ModuleInfoJSON()
2159 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2160 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2161 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2162 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2163 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2164
2165 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2166 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2167 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2168 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2169
2170 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2171 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2172 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2173 moduleInfoJSON.SubName += ".cfi"
2174 }
2175 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2176 moduleInfoJSON.SubName += ".hwasan"
2177 }
2178 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2179 moduleInfoJSON.SubName += ".scs"
2180 }
2181 }
2182 moduleInfoJSON.SubName += c.Properties.SubName
2183
2184 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2185 moduleInfoJSON.Uninstallable = true
2186 }
2187
2188 }
Chris Parsons94a0bba2021-06-04 15:03:47 -04002189}
2190
2191func (c *Module) maybeUnhideFromMake() {
2192 // If a lib is directly included in any of the APEXes or is not available to the
2193 // platform (which is often the case when the stub is provided as a prebuilt),
2194 // unhide the stubs variant having the latest version gets visible to make. In
2195 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2196 // force anything in the make world to link against the stubs library. (unless it
2197 // is explicitly referenced via .bootstrap suffix or the module is marked with
2198 // 'bootstrap: true').
2199 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002200 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002201 c.IsStubs() && !c.InVendorRamdisk() {
2202 c.Properties.HideFromMake = false // unhide
2203 // Note: this is still non-installable
2204 }
2205}
2206
Colin Cross8ff10582023-12-07 13:10:56 -08002207// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2208// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002209func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002210 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002211 // If the module has been specifically configure to not be installed then
2212 // hide from make as otherwise it will break when running inside make
2213 // as the output path to install will not be specified. Not all uninstallable
2214 // modules can be hidden from make as some are needed for resolving make side
2215 // dependencies.
2216 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002217 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002218 c.SkipInstall()
2219 }
2220
2221 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2222 // to allow using the outputs in a genrule.
2223 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002224 c.installer.install(ctx, c.outputFile.Path())
2225 if ctx.Failed() {
2226 return
Colin Crossca860ac2016-01-04 14:34:37 -08002227 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002228 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002229}
2230
Colin Cross0ea8ba82019-06-06 14:33:29 -07002231func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002232 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002233 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002234 }
Colin Crossca860ac2016-01-04 14:34:37 -08002235 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002236}
2237
Colin Crossca860ac2016-01-04 14:34:37 -08002238func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002239 for _, generator := range c.generators {
2240 generator.GeneratorInit(ctx)
2241 }
Colin Crossca860ac2016-01-04 14:34:37 -08002242 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002243 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002244 }
Colin Crossca860ac2016-01-04 14:34:37 -08002245 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002246 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002247 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002248 if c.stl != nil {
2249 c.stl.begin(ctx)
2250 }
Colin Cross16b23492016-01-06 14:41:07 -08002251 if c.sanitize != nil {
2252 c.sanitize.begin(ctx)
2253 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002254 if c.coverage != nil {
2255 c.coverage.begin(ctx)
2256 }
Yi Kong9723e332023-12-04 14:52:53 +09002257 if c.afdo != nil {
2258 c.afdo.begin(ctx)
2259 }
Stephen Craneba090d12017-05-09 15:44:35 -07002260 if c.lto != nil {
2261 c.lto.begin(ctx)
2262 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002263 if c.orderfile != nil {
2264 c.orderfile.begin(ctx)
2265 }
Dan Albert92fe7402020-07-15 13:33:30 -07002266 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002267 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002268 if err != nil {
2269 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002270 c.Properties.Sdk_version = nil
2271 } else {
2272 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002273 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002274 }
Colin Crossca860ac2016-01-04 14:34:37 -08002275}
2276
Colin Cross37047f12016-12-13 17:06:13 -08002277func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002278 deps := Deps{}
2279
Joe Onorato37f900c2023-07-18 16:58:16 -07002280 for _, generator := range c.generators {
2281 deps = generator.GeneratorDeps(ctx, deps)
2282 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002283 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002284 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002285 }
2286 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002287 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002288 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002289 if c.stl != nil {
2290 deps = c.stl.deps(ctx, deps)
2291 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002292 if c.coverage != nil {
2293 deps = c.coverage.deps(ctx, deps)
2294 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002295
Colin Crossb6715442017-10-24 11:13:31 -07002296 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2297 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2298 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2299 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2300 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2301 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002302 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002303
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002304 for _, lib := range deps.ReexportSharedLibHeaders {
2305 if !inList(lib, deps.SharedLibs) {
2306 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2307 }
2308 }
2309
2310 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002311 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2312 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 -07002313 }
2314 }
2315
Colin Cross5950f382016-12-13 12:50:57 -08002316 for _, lib := range deps.ReexportHeaderLibHeaders {
2317 if !inList(lib, deps.HeaderLibs) {
2318 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2319 }
2320 }
2321
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002322 for _, gen := range deps.ReexportGeneratedHeaders {
2323 if !inList(gen, deps.GeneratedHeaders) {
2324 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2325 }
2326 }
2327
Colin Crossc99deeb2016-04-11 15:06:20 -07002328 return deps
2329}
2330
Dan Albert7e9d2952016-08-04 13:02:36 -07002331func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002332 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002333 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002334 moduleContextImpl: moduleContextImpl{
2335 mod: c,
2336 },
2337 }
2338 ctx.ctx = ctx
2339
Colin Crossca860ac2016-01-04 14:34:37 -08002340 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002341}
2342
Jiyong Park7ed9de32018-10-15 22:25:07 +09002343// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002344func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002345 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2346 version := name[sharp+1:]
2347 libname := name[:sharp]
2348 return libname, version
2349 }
2350 return name, ""
2351}
2352
Dan Albert92fe7402020-07-15 13:33:30 -07002353func GetCrtVariations(ctx android.BottomUpMutatorContext,
2354 m LinkableInterface) []blueprint.Variation {
2355 if ctx.Os() != android.Android {
2356 return nil
2357 }
2358 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002359 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2360 minSdkVersion := m.MinSdkVersion()
2361 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2362 minSdkVersion = m.SdkVersion()
2363 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002364 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2365 if err != nil {
2366 ctx.PropertyErrorf("min_sdk_version", err.Error())
2367 }
Colin Cross363ec762023-01-13 13:45:14 -08002368
2369 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002370 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002371 if apiLevel.LessThan(minApiForArch) {
2372 apiLevel = minApiForArch
2373 }
2374
Dan Albert92fe7402020-07-15 13:33:30 -07002375 return []blueprint.Variation{
2376 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002377 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002378 }
2379 }
2380 return []blueprint.Variation{
2381 {Mutator: "sdk", Variation: ""},
2382 }
2383}
2384
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002385func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2386 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002387
2388 variations = append([]blueprint.Variation(nil), variations...)
2389
Liz Kammer23942242022-04-08 15:41:00 -04002390 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002391 // Version is explicitly specified. i.e. libFoo#30
2392 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002393 if tag, ok := depTag.(libraryDependencyTag); ok {
2394 tag.explicitlyVersioned = true
2395 } else {
2396 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2397 }
Colin Crosse7257d22020-09-24 09:56:18 -07002398 }
Colin Crosse7257d22020-09-24 09:56:18 -07002399
Colin Cross0de8a1e2020-09-18 14:15:30 -07002400 if far {
2401 ctx.AddFarVariationDependencies(variations, depTag, name)
2402 } else {
2403 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002404 }
2405}
2406
Kiyoung Kim487689e2022-07-26 09:48:22 +09002407func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2408 apiImportInfo := multitree.ApiImportInfo{}
2409
2410 if c.Device() {
2411 var apiImportModule []blueprint.Module
2412 if actx.OtherModuleExists("api_imports") {
2413 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2414 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
Colin Cross313aa542023-12-13 13:47:44 -08002415 apiInfo, _ := android.OtherModuleProvider(actx, apiImportModule[0], multitree.ApiImportsProvider)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002416 apiImportInfo = apiInfo
Colin Cross40213022023-12-13 15:19:49 -08002417 android.SetProvider(actx, multitree.ApiImportsProvider, apiInfo)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002418 }
2419 }
2420 }
2421
2422 return apiImportInfo
2423}
2424
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002425func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002426 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002427 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002428 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002429 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2430 // between the modules in the snapshot and the snapshot itself.
2431 var snapshotModule []blueprint.Module
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +09002432 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() && actx.OtherModuleExists("vendor_snapshot") {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002433 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +09002434 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() && actx.OtherModuleExists("recovery_snapshot") {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002435 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2436 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002437 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Colin Cross313aa542023-12-13 13:47:44 -08002438 snapshot, _ := android.OtherModuleProvider(actx, snapshotModule[0], SnapshotInfoProvider)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002439 *snapshotInfo = &snapshot
2440 // republish the snapshot for use in later mutators on this module
Colin Cross40213022023-12-13 15:19:49 -08002441 android.SetProvider(actx, SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002442 }
2443 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002444 if *snapshotInfo == nil {
2445 *snapshotInfo = &SnapshotInfo{}
2446 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002447 return **snapshotInfo
2448}
2449
Kiyoung Kim487689e2022-07-26 09:48:22 +09002450func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2451 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002452 return snapshot
2453 }
2454
2455 return lib
2456}
2457
2458// RewriteLibs takes a list of names of shared libraries and scans it for three types
2459// of names:
2460//
2461// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002462//
2463// For each of these, it adds the name of the prebuilt module (which will be in
2464// prebuilts/ndk) to the list of nonvariant libs.
2465//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002466// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002467//
2468// For each of these, it adds the name of the ndk_library module to the list of
2469// variant libs.
2470//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002471// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002472//
2473// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002474//
2475// The caller can then know to add the variantLibs dependencies differently from the
2476// nonvariantLibs
2477func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2478 variantLibs = []string{}
2479
2480 nonvariantLibs = []string{}
2481 for _, entry := range list {
2482 // strip #version suffix out
2483 name, _ := StubsLibNameAndVersion(entry)
2484 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002485 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002486 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2487 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2488 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002489 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002490 } else {
2491 // put name#version back
2492 nonvariantLibs = append(nonvariantLibs, entry)
2493 }
2494 }
2495 return nonvariantLibs, variantLibs
2496}
2497
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002498func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2499 nonVariantLibs := []string{}
2500 variantLibs := []string{}
2501
2502 for _, lib := range libs {
2503 replaceLibName := GetReplaceModuleName(lib, replaceList)
2504 if replaceLibName == lib {
2505 // Do not handle any libs which are not in API imports
2506 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2507 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2508 variantLibs = append(variantLibs, replaceLibName)
2509 } else {
2510 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2511 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002512 }
2513
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002514 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002515}
2516
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002517func (c *Module) shouldUseApiSurface() bool {
2518 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2519 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2520 // LLNDK Variant
2521 return true
2522 }
2523
2524 if c.Properties.IsSdkVariant {
2525 // NDK Variant
2526 return true
2527 }
2528
2529 if c.isImportedApiLibrary() {
2530 // API Library should depend on API headers
2531 return true
2532 }
2533 }
2534
2535 return false
2536}
2537
Colin Cross1e676be2016-10-12 14:38:15 -07002538func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002539 if !c.Enabled() {
2540 return
2541 }
2542
Colin Cross37047f12016-12-13 17:06:13 -08002543 ctx := &depsContext{
2544 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002545 moduleContextImpl: moduleContextImpl{
2546 mod: c,
2547 },
2548 }
2549 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002550
Colin Crossc99deeb2016-04-11 15:06:20 -07002551 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002552 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002553
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002554 apiNdkLibs := []string{}
2555 apiLateNdkLibs := []string{}
2556
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002557 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002558 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2559 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2560 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2561 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2562 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002563 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002564
Yo Chiang219968c2020-09-22 18:45:04 +08002565 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2566
Colin Crosse0edaf92021-01-11 17:31:17 -08002567 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002568
Dan Albert914449f2016-06-17 16:45:24 -07002569 variantNdkLibs := []string{}
2570 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002571 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002572 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2573 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2574 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002575
2576 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002577 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002578 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002579 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002580
Colin Cross32ec36c2016-12-15 07:39:51 -08002581 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002582 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002583 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002584 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002585 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002586
Kiyoung Kim51279d32022-08-24 14:10:46 +09002587 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002588 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002589 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2590 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002591 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002592
Spandan Das73bcafc2022-08-18 23:26:00 +00002593 if c.isNDKStubLibrary() {
2594 // ndk_headers do not have any variations
2595 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002596 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002597 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002598 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002599 } else {
2600 actx.AddVariationDependencies(nil, depTag, lib)
2601 }
2602 }
2603
Dan Albertf1d14c72020-07-30 14:32:55 -07002604 if c.isNDKStubLibrary() {
2605 // NDK stubs depend on their implementation because the ABI dumps are
2606 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002607
Spandan Das8b08aea2023-03-14 19:29:34 +00002608 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2609 c.ImageVariation(),
2610 blueprint.Variation{Mutator: "link", Variation: "shared"},
2611 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002612 }
2613
Jiyong Park5d1598f2019-02-25 22:14:17 +09002614 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002615 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002616
Kiyoung Kim487689e2022-07-26 09:48:22 +09002617 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002618
Jiyong Park5d1598f2019-02-25 22:14:17 +09002619 actx.AddVariationDependencies([]blueprint.Variation{
2620 {Mutator: "link", Variation: "static"},
2621 }, depTag, lib)
2622 }
2623
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002624 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002625 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002626 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002627 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002628 }
Jiyong Parke3867542020-12-03 17:28:25 +09002629 if inList(lib, deps.ExcludeLibsForApex) {
2630 depTag.excludeInApex = true
2631 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002632
Kiyoung Kim487689e2022-07-26 09:48:22 +09002633 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002634
Dan Willemsen59339a22018-07-22 21:18:45 -07002635 actx.AddVariationDependencies([]blueprint.Variation{
2636 {Mutator: "link", Variation: "static"},
2637 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002638 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002639
Jooyung Han75568392020-03-20 04:29:24 +09002640 // staticUnwinderDep is treated as staticDep for Q apexes
2641 // so that native libraries/binaries are linked with static unwinder
2642 // because Q libc doesn't have unwinder APIs
2643 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002644 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002645 actx.AddVariationDependencies([]blueprint.Variation{
2646 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002647 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002648 }
2649
Jiyong Park7ed9de32018-10-15 22:25:07 +09002650 // shared lib names without the #version suffix
2651 var sharedLibNames []string
2652
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002653 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002654 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002655 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002656 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002657 }
Jiyong Parke3867542020-12-03 17:28:25 +09002658 if inList(lib, deps.ExcludeLibsForApex) {
2659 depTag.excludeInApex = true
2660 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002661 if inList(lib, deps.ExcludeLibsForNonApex) {
2662 depTag.excludeInNonApex = true
2663 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002664
Jiyong Park73c54ee2019-10-22 20:31:18 +09002665 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002666 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2667 name = apiLibraryName
2668 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002669 sharedLibNames = append(sharedLibNames, name)
2670
Colin Crosse7257d22020-09-24 09:56:18 -07002671 variations := []blueprint.Variation{
2672 {Mutator: "link", Variation: "shared"},
2673 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002674
2675 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2676 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2677 }
2678
2679 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2680 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2681 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002682 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002683
Colin Crossfe9acfe2021-06-14 16:13:03 -07002684 for _, lib := range deps.LateStaticLibs {
2685 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2686 actx.AddVariationDependencies([]blueprint.Variation{
2687 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002688 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002689 }
2690
Colin Cross3e5e7782022-06-17 22:17:05 +00002691 for _, lib := range deps.UnexportedStaticLibs {
2692 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2693 actx.AddVariationDependencies([]blueprint.Variation{
2694 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002695 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002696 }
2697
Jiyong Park7ed9de32018-10-15 22:25:07 +09002698 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002699 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002700 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2701 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2702 // linking against both the stubs lib and the non-stubs lib at the same time.
2703 continue
2704 }
Colin Cross6e511a92020-07-27 21:26:48 -07002705 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002706 variations := []blueprint.Variation{
2707 {Mutator: "link", Variation: "shared"},
2708 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002709 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002710 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002711
Dan Willemsen59339a22018-07-22 21:18:45 -07002712 actx.AddVariationDependencies([]blueprint.Variation{
2713 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002714 }, dataLibDepTag, deps.DataLibs...)
2715
Colin Crossc8caa062021-09-24 16:50:14 -07002716 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2717
Chris Parsons79d66a52020-06-05 17:26:16 -04002718 actx.AddVariationDependencies([]blueprint.Variation{
2719 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002720 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002721
Colin Cross68861832016-07-08 10:41:41 -07002722 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002723
2724 for _, gen := range deps.GeneratedHeaders {
2725 depTag := genHeaderDepTag
2726 if inList(gen, deps.ReexportGeneratedHeaders) {
2727 depTag = genHeaderExportDepTag
2728 }
2729 actx.AddDependency(c, depTag, gen)
2730 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002731
Dan Albert92fe7402020-07-15 13:33:30 -07002732 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002733 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002734 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002735 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002736 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002737 }
Colin Crossc465efd2021-06-11 18:00:04 -07002738 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002739 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002740 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002741 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002742 if deps.DynamicLinker != "" {
2743 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002744 }
Dan Albert914449f2016-06-17 16:45:24 -07002745
2746 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002747
2748 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002749 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002750 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002751 {Mutator: "link", Variation: "shared"},
2752 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002753 actx.AddVariationDependencies([]blueprint.Variation{
2754 {Mutator: "version", Variation: version},
2755 {Mutator: "link", Variation: "shared"},
2756 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002757
2758 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002759 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002760 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002761 {Mutator: "link", Variation: "shared"},
2762 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002763 actx.AddVariationDependencies([]blueprint.Variation{
2764 {Mutator: "version", Variation: version},
2765 {Mutator: "link", Variation: "shared"},
2766 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002767
2768 if vndkdep := c.vndkdep; vndkdep != nil {
2769 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002770 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002771 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002772 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002773 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002774 }
2775 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002776
Vinh Tran367d89d2023-04-28 11:21:25 -04002777 if len(deps.AidlLibs) > 0 {
2778 actx.AddDependency(
2779 c,
2780 aidlLibraryTag,
2781 deps.AidlLibs...,
2782 )
2783 }
2784
Kiyoung Kimee58c932022-10-25 22:59:41 +09002785 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002786}
Colin Cross21b9a242015-03-24 14:15:58 -07002787
Colin Crosse40b4ea2018-10-02 22:25:58 -07002788func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002789 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2790 c.beginMutator(ctx)
2791 }
2792}
2793
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002794// Whether a module can link to another module, taking into
2795// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002796func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002797 tag blueprint.DependencyTag) {
2798
2799 switch t := tag.(type) {
2800 case dependencyTag:
2801 if t != vndkExtDepTag {
2802 return
2803 }
2804 case libraryDependencyTag:
2805 default:
2806 return
2807 }
2808
Ivan Lozanof9e21722020-12-02 09:00:51 -05002809 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002810 // Host code is not restricted
2811 return
2812 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002813
2814 // VNDK is cc.Module supported only for now.
2815 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002816 // Though allowed dependency is limited by the image mutator,
2817 // each vendor and product module needs to check link-type
2818 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002819 if ccTo, ok := to.(*Module); ok {
2820 if ccFrom.vndkdep != nil {
2821 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2822 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002823 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002824 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002825 }
2826 return
2827 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002828 // TODO(b/244244438) : Remove this once all variants are implemented
2829 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2830 return
2831 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002832 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002833 // Platform code can link to anything
2834 return
2835 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002836 if from.InRamdisk() {
2837 // Ramdisk code is not NDK
2838 return
2839 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002840 if from.InVendorRamdisk() {
2841 // Vendor ramdisk code is not NDK
2842 return
2843 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002844 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002845 // Recovery code is not NDK
2846 return
2847 }
Colin Cross31076b32020-10-23 17:22:06 -07002848 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002849 if c.NdkPrebuiltStl() {
2850 // These are allowed, but they don't set sdk_version
2851 return
2852 }
2853 if c.StubDecorator() {
2854 // These aren't real libraries, but are the stub shared libraries that are included in
2855 // the NDK.
2856 return
2857 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002858 if c.isImportedApiLibrary() {
2859 // Imported library from the API surface is a stub library built against interface definition.
2860 return
2861 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002862 }
Logan Chien834b9a62019-01-14 15:39:03 +08002863
Ivan Lozano52767be2019-10-18 14:49:46 -07002864 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002865 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2866 // to link to libc++ (non-NDK and without sdk_version).
2867 return
2868 }
2869
Ivan Lozano52767be2019-10-18 14:49:46 -07002870 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002871 // NDK code linking to platform code is never okay.
2872 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002873 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002874 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002875 }
2876
2877 // At this point we know we have two NDK libraries, but we need to
2878 // check that we're not linking against anything built against a higher
2879 // API level, as it is only valid to link against older or equivalent
2880 // APIs.
2881
Inseob Kim01a28722018-04-11 09:48:45 +09002882 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002883 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002884 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002885 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002886 // Current can't be linked against by anything else.
2887 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002888 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002889 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002890 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002891 if err != nil {
2892 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002893 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002894 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002895 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002896 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.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 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002901 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002902
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002903 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002904 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002905 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002906 }
2907 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002908 }
Dan Albert202fe492017-12-15 13:56:59 -08002909
2910 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002911 fromStl := from.SelectedStl()
2912 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002913 if fromStl == "" || toStl == "" {
2914 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002915 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002916 // We can be permissive with the system "STL" since it is only the C++
2917 // ABI layer, but in the future we should make sure that everyone is
2918 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002919 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002920 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002921 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2922 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002923 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002924}
2925
Jooyung Han479ca172020-10-19 18:51:07 +09002926func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2927 if c, ok := ctx.Module().(*Module); ok {
2928 ctx.VisitDirectDeps(func(dep android.Module) {
2929 depTag := ctx.OtherModuleDependencyTag(dep)
2930 ccDep, ok := dep.(LinkableInterface)
2931 if ok {
2932 checkLinkType(ctx, c, ccDep, depTag)
2933 }
2934 })
2935 }
2936}
2937
Jiyong Park5fb8c102018-04-09 12:03:06 +09002938// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002939// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2940// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002941// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002942func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2943 check := func(child, parent android.Module) bool {
2944 to, ok := child.(*Module)
2945 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002946 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002947 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002948
Jooyung Hana70f0672019-01-18 15:20:43 +09002949 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2950 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002951 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002952
Jiyong Park0474e1f2021-01-14 14:26:06 +09002953 // These dependencies are not excercised at runtime. Tracking these will give us
2954 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002955 depTag := ctx.OtherModuleDependencyTag(child)
2956 if IsHeaderDepTag(depTag) {
2957 return false
2958 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002959 if depTag == staticVariantTag {
2960 return false
2961 }
2962 if depTag == stubImplDepTag {
2963 return false
2964 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002965
Justin Yun63e9ec72020-10-29 16:49:43 +09002966 // Even if target lib has no vendor variant, keep checking dependency
2967 // graph in case it depends on vendor_available or product_available
2968 // but not double_loadable transtively.
2969 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002970 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002971 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002972
Jiyong Park0474e1f2021-01-14 14:26:06 +09002973 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2974 // one.
2975 if Bool(to.VendorProperties.Double_loadable) {
2976 return true
2977 }
2978
Ivan Lozanod7586b62021-04-01 09:49:36 -04002979 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002980 return false
2981 }
2982
Jooyung Hana70f0672019-01-18 15:20:43 +09002983 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2984 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002985 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002986 return false
2987 }
2988 if module, ok := ctx.Module().(*Module); ok {
2989 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002990 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002991 ctx.WalkDeps(check)
2992 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002993 }
2994 }
2995}
2996
Yu Liue4312402023-01-18 09:15:31 -08002997func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2998 // For the dependency from platform to apex, use the latest stubs
2999 apexSdkVersion := android.FutureApiLevel
3000 if !apexInfo.IsForPlatform() {
3001 apexSdkVersion = apexInfo.MinSdkVersion
3002 }
3003
3004 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
3005 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
3006 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
3007 // (b/144430859)
3008 apexSdkVersion = android.FutureApiLevel
3009 }
3010
3011 return apexSdkVersion
3012}
3013
Colin Crossc99deeb2016-04-11 15:06:20 -07003014// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07003015func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08003016 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08003017
Colin Cross0de8a1e2020-09-18 14:15:30 -07003018 var directStaticDeps []StaticLibraryInfo
3019 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07003020
Colin Cross0de8a1e2020-09-18 14:15:30 -07003021 reexportExporter := func(exporter FlagExporterInfo) {
3022 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
3023 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
3024 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
3025 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
3026 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09003027 }
3028
Colin Crossff694a82023-12-13 15:54:49 -08003029 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08003030 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09003031
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003032 skipModuleList := map[string]bool{}
3033
3034 var apiImportInfo multitree.ApiImportInfo
3035 hasApiImportInfo := false
3036
3037 ctx.VisitDirectDeps(func(dep android.Module) {
3038 if dep.Name() == "api_imports" {
Colin Cross313aa542023-12-13 13:47:44 -08003039 apiImportInfo, _ = android.OtherModuleProvider(ctx, dep, multitree.ApiImportsProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003040 hasApiImportInfo = true
3041 }
3042 })
3043
3044 if hasApiImportInfo {
3045 targetStubModuleList := map[string]string{}
3046 targetOrigModuleList := map[string]string{}
3047
3048 // Search for dependency which both original module and API imported library with APEX stub exists
3049 ctx.VisitDirectDeps(func(dep android.Module) {
3050 depName := ctx.OtherModuleName(dep)
3051 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
3052 targetStubModuleList[apiLibrary] = depName
3053 }
3054 })
3055 ctx.VisitDirectDeps(func(dep android.Module) {
3056 depName := ctx.OtherModuleName(dep)
3057 if origLibrary, ok := targetStubModuleList[depName]; ok {
3058 targetOrigModuleList[origLibrary] = depName
3059 }
3060 })
3061
3062 // Decide which library should be used between original and API imported library
3063 ctx.VisitDirectDeps(func(dep android.Module) {
3064 depName := ctx.OtherModuleName(dep)
3065 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00003066 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003067 skipModuleList[depName] = true
3068 } else {
3069 skipModuleList[apiLibrary] = true
3070 }
3071 }
3072 })
3073 }
3074
Colin Crossd11fcda2017-10-23 17:59:01 -07003075 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003076 depName := ctx.OtherModuleName(dep)
3077 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07003078
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003079 if _, ok := skipModuleList[depName]; ok {
3080 // skip this module because original module or API imported module matching with this should be used instead.
3081 return
3082 }
3083
Dan Willemsen47450072021-10-19 20:24:49 -07003084 if depTag == android.DarwinUniversalVariantTag {
3085 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3086 return
3087 }
3088
Vinh Tran367d89d2023-04-28 11:21:25 -04003089 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08003090 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04003091 depPaths.AidlLibraryInfos = append(
3092 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08003093 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04003094 )
3095 }
3096 }
3097
Ivan Lozano52767be2019-10-18 14:49:46 -07003098 ccDep, ok := dep.(LinkableInterface)
3099 if !ok {
3100
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003101 // handling for a few module types that aren't cc Module but that are also supported
3102 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003103 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003104 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003105 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3106 genRule.GeneratedSourceFiles()...)
3107 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003108 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003109 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003110 // Support exported headers from a generated_sources dependency
3111 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003112 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003113 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003114 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003115 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003116 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003117 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003118 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003119 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003120 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3121 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003122 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003123 // 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 +09003124 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003125
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003126 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003127 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003128 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003129 }
Colin Crosscef792e2021-06-11 18:01:26 -07003130 case CrtBeginDepTag:
3131 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3132 case CrtEndDepTag:
3133 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003134 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003135 return
3136 }
3137
Colin Crossfe17f6f2019-03-28 19:30:56 -07003138 if depTag == android.ProtoPluginDepTag {
3139 return
3140 }
3141
Colin Crossd11fcda2017-10-23 17:59:01 -07003142 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003143 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3144 return
3145 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003146 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003147 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3148 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003149 return
3150 }
3151
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003152 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003153 // Skip reused objects for stub libraries, they use their own stub object file instead.
3154 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3155 // version mutator, so the stubs variant is created from the shared variant that
3156 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003157 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003158 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003159 objs := staticAnalogue.ReuseObjects
3160 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003161 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003162 reexportExporter(depExporterInfo)
3163 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003164 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003165 }
3166
Colin Cross6e511a92020-07-27 21:26:48 -07003167 linkFile := ccDep.OutputFile()
3168
3169 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3170 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003171 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003172 return
3173 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003174
Jiyong Parke3867542020-12-03 17:28:25 +09003175 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3176 return
3177 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003178 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3179 return
3180 }
Jiyong Parke3867542020-12-03 17:28:25 +09003181
Colin Cross313aa542023-12-13 13:47:44 -08003182 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003183
Colin Cross6e511a92020-07-27 21:26:48 -07003184 var ptr *android.Paths
3185 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003186
Colin Cross6e511a92020-07-27 21:26:48 -07003187 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003188
Colin Cross6e511a92020-07-27 21:26:48 -07003189 switch {
3190 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003191 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003192 if !ctx.Config().AllowMissingDependencies() {
3193 ctx.ModuleErrorf("module %q is not a header library", depName)
3194 } else {
3195 ctx.AddMissingDependencies([]string{depName})
3196 }
3197 return
3198 }
Colin Cross6e511a92020-07-27 21:26:48 -07003199 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003200 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003201 if !ctx.Config().AllowMissingDependencies() {
3202 ctx.ModuleErrorf("module %q is not a shared library", depName)
3203 } else {
3204 ctx.AddMissingDependencies([]string{depName})
3205 }
3206 return
3207 }
Jiyong Parke3867542020-12-03 17:28:25 +09003208
Jiyong Park7d55b612021-06-11 17:22:09 +09003209 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3210 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003211
Jiyong Park1ad8e162020-12-01 23:40:09 +09003212 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3213 // linkFile, depFile, and ptr.
3214 if c.IsStubs() {
3215 break
3216 }
3217
Colin Cross0de8a1e2020-09-18 14:15:30 -07003218 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3219 depFile = sharedLibraryInfo.TableOfContents
3220
Colin Cross6e511a92020-07-27 21:26:48 -07003221 ptr = &depPaths.SharedLibs
3222 switch libDepTag.Order {
3223 case earlyLibraryDependency:
3224 ptr = &depPaths.EarlySharedLibs
3225 depPtr = &depPaths.EarlySharedLibsDeps
3226 case normalLibraryDependency:
3227 ptr = &depPaths.SharedLibs
3228 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003229 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003230 case lateLibraryDependency:
3231 ptr = &depPaths.LateSharedLibs
3232 depPtr = &depPaths.LateSharedLibsDeps
3233 default:
3234 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003235 }
Colin Cross6e511a92020-07-27 21:26:48 -07003236 case libDepTag.static():
Colin Cross313aa542023-12-13 13:47:44 -08003237 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3238 if !isStaticLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003239 if !ctx.Config().AllowMissingDependencies() {
3240 ctx.ModuleErrorf("module %q is not a static library", depName)
3241 } else {
3242 ctx.AddMissingDependencies([]string{depName})
3243 }
3244 return
3245 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003246
3247 // Stubs lib doesn't link to the static lib dependencies. Don't set
3248 // linkFile, depFile, and ptr.
3249 if c.IsStubs() {
3250 break
3251 }
3252
Colin Cross0de8a1e2020-09-18 14:15:30 -07003253 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003254 if libDepTag.wholeStatic {
3255 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003256 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3257 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003258 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003259 // This case normally catches prebuilt static
3260 // libraries, but it can also occur when
3261 // AllowMissingDependencies is on and the
3262 // dependencies has no sources of its own
3263 // but has a whole_static_libs dependency
3264 // on a missing library. We want to depend
3265 // on the .a file so that there is something
3266 // in the dependency tree that contains the
3267 // error rule for the missing transitive
3268 // dependency.
3269 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003270 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003271 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3272 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003273 } else {
3274 switch libDepTag.Order {
3275 case earlyLibraryDependency:
3276 panic(fmt.Errorf("early static libs not suppported"))
3277 case normalLibraryDependency:
3278 // static dependencies will be handled separately so they can be ordered
3279 // using transitive dependencies.
3280 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003281 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003282 case lateLibraryDependency:
3283 ptr = &depPaths.LateStaticLibs
3284 default:
3285 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003286 }
3287 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003288 if libDepTag.unexportedSymbols {
3289 depPaths.LdFlags = append(depPaths.LdFlags,
3290 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3291 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003292 }
3293
Colin Cross6e511a92020-07-27 21:26:48 -07003294 if libDepTag.static() && !libDepTag.wholeStatic {
3295 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3296 ctx.ModuleErrorf("module %q not a static library", depName)
3297 return
3298 }
Logan Chien43d34c32017-12-20 01:17:32 +08003299
Colin Cross6e511a92020-07-27 21:26:48 -07003300 // When combining coverage files for shared libraries and executables, coverage files
3301 // in static libraries act as if they were whole static libraries. The same goes for
3302 // source based Abi dump files.
3303 if c, ok := ccDep.(*Module); ok {
3304 staticLib := c.linker.(libraryInterface)
3305 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3306 staticLib.objs().coverageFiles...)
3307 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3308 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003309 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003310 // Handle non-CC modules here
3311 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003312 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003313 }
3314 }
3315
Colin Cross6e511a92020-07-27 21:26:48 -07003316 if ptr != nil {
3317 if !linkFile.Valid() {
3318 if !ctx.Config().AllowMissingDependencies() {
3319 ctx.ModuleErrorf("module %q missing output file", depName)
3320 } else {
3321 ctx.AddMissingDependencies([]string{depName})
3322 }
3323 return
3324 }
3325 *ptr = append(*ptr, linkFile.Path())
3326 }
3327
3328 if depPtr != nil {
3329 dep := depFile
3330 if !dep.Valid() {
3331 dep = linkFile
3332 }
3333 *depPtr = append(*depPtr, dep.Path())
3334 }
3335
Colin Cross0de8a1e2020-09-18 14:15:30 -07003336 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3337 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3338 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3339 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3340
3341 if libDepTag.reexportFlags {
3342 reexportExporter(depExporterInfo)
3343 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3344 // Re-exported shared library headers must be included as well since they can help us with type information
3345 // about template instantiations (instantiated from their headers).
3346 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3347 // scripts.
3348 c.sabi.Properties.ReexportedIncludes = append(
3349 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3350 }
3351
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003352 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003353 switch {
3354 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003355 c.Properties.AndroidMkHeaderLibs = append(
3356 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003357 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003358 if lib := moduleLibraryInterface(dep); lib != nil {
3359 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003360 // Add the dependency to the APEX(es) providing the library so that
3361 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003362 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003363 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003364 c.Properties.ApexesProvidingSharedLibs = append(
3365 c.Properties.ApexesProvidingSharedLibs, an)
3366 }
3367 }
3368 }
3369
3370 // Note: the order of libs in this list is not important because
3371 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003372 c.Properties.AndroidMkSharedLibs = append(
3373 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003374 // Record BaseLibName for snapshots.
3375 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003376 case libDepTag.static():
3377 if libDepTag.wholeStatic {
3378 c.Properties.AndroidMkWholeStaticLibs = append(
3379 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3380 } else {
3381 c.Properties.AndroidMkStaticLibs = append(
3382 c.Properties.AndroidMkStaticLibs, makeLibName)
3383 }
Justin Yun5e035862021-06-29 20:50:37 +09003384 // Record BaseLibName for snapshots.
3385 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003386 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003387 } else if !c.IsStubs() {
3388 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3389
Colin Cross6e511a92020-07-27 21:26:48 -07003390 switch depTag {
3391 case runtimeDepTag:
3392 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003393 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003394 // Record BaseLibName for snapshots.
3395 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003396 case objDepTag:
3397 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3398 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003399 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003400 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003401 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003402 case dynamicLinkerDepTag:
3403 depPaths.DynamicLinker = linkFile
3404 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003405 }
Colin Crossca860ac2016-01-04 14:34:37 -08003406 })
3407
Jeff Gaston294356f2017-09-27 17:05:30 -07003408 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003409 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3410 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3411 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003412
Colin Crossdd84e052017-05-17 13:44:16 -07003413 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003414 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003415 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3416 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003417 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003418 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3419 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003420 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003421 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003422 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003423
3424 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003425 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003426 }
Colin Crossdd84e052017-05-17 13:44:16 -07003427
Colin Crossca860ac2016-01-04 14:34:37 -08003428 return depPaths
3429}
3430
Spandan Das604f3762023-03-16 22:51:40 +00003431func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003432 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003433 thisModule, ok := ctx.Module().(android.ApexModule)
3434 if !ok {
3435 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3436 }
3437
Kiyoung Kimaa394802024-01-08 12:55:45 +09003438 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003439 bootstrap := false
3440 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3441 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3442 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003443 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003444 bootstrap = linkable.Bootstrap()
3445 }
3446
Colin Crossff694a82023-12-13 15:54:49 -08003447 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003448
3449 useStubs := false
3450
Kiyoung Kimaa394802024-01-08 12:55:45 +09003451 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003452 if !apexInfo.IsForPlatform() {
3453 // For platform libraries, use current version of LLNDK
3454 // If this is for use_vendor apex we will apply the same rules
3455 // of apex sdk enforcement below to choose right version.
3456 useStubs = true
3457 }
3458 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3459 // If not building for APEX or the containing APEX allows the use of
3460 // platform APIs, use stubs only when it is from an APEX (and not from
3461 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3462 // bootstrap modules, always link to non-stub variant
3463 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3464
3465 isApexImportedApiLibrary := false
3466
3467 if cc, ok := dep.(*Module); ok {
3468 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3469 if apiLibrary.hasApexStubs() {
3470 isApexImportedApiLibrary = true
3471 }
3472 }
3473 }
3474
3475 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3476
3477 if useStubs {
3478 // Another exception: if this module is a test for an APEX, then
3479 // it is linked with the non-stub variant of a module in the APEX
3480 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003481 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003482 for _, apexContents := range testFor.ApexContents {
3483 if apexContents.DirectlyInApex(depName) {
3484 useStubs = false
3485 break
3486 }
3487 }
3488 }
3489 if useStubs {
3490 // Yet another exception: If this module and the dependency are
3491 // available to the same APEXes then skip stubs between their
3492 // platform variants. This complements the test_for case above,
3493 // which avoids the stubs on a direct APEX library dependency, by
3494 // avoiding stubs for indirect test dependencies as well.
3495 //
3496 // TODO(b/183882457): This doesn't work if the two libraries have
3497 // only partially overlapping apex_available. For that test_for
3498 // modules would need to be split into APEX variants and resolved
3499 // separately for each APEX they have access to.
3500 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3501 useStubs = false
3502 }
3503 }
3504 } else {
3505 // If building for APEX, use stubs when the parent is in any APEX that
3506 // the child is not in.
3507 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3508 }
3509
3510 return useStubs
3511}
3512
3513// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3514// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3515// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3516// has different level of updatability. For example, if a library foo in an APEX depends on a
3517// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3518// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3519// same APEX as foo, the non-stub variant of bar is used.
3520func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3521 depTag := ctx.OtherModuleDependencyTag(dep)
3522 libDepTag, ok := depTag.(libraryDependencyTag)
3523 if !ok || !libDepTag.shared() {
3524 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3525 }
3526
Colin Cross313aa542023-12-13 13:47:44 -08003527 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3528 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3529 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003530
3531 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003532 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003533 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003534 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3535 toUse := stubs[len(stubs)-1]
3536 sharedLibraryInfo = toUse.SharedLibraryInfo
3537 depExporterInfo = toUse.FlagExporterInfo
3538 }
3539 }
3540 return sharedLibraryInfo, depExporterInfo
3541}
3542
Colin Cross0de8a1e2020-09-18 14:15:30 -07003543// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3544// to match the topological order of the dependency tree, including any static analogues of
3545// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3546// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003547func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3548 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003549 var staticPaths android.Paths
3550 for _, staticDep := range staticDeps {
3551 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3552 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3553 }
3554 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003555 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3556 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003557 }
3558 }
3559 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3560
3561 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3562
3563 // reorder the dependencies based on transitive dependencies
3564 staticPaths = android.FirstUniquePaths(staticPaths)
3565 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3566
3567 if len(orderedStaticPaths) != len(staticPaths) {
3568 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3569 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3570 }
3571
3572 return orderedStaticPaths, transitiveStaticLibs
3573}
3574
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003575// BaseLibName trims known prefixes and suffixes
3576func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003577 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3578 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003579 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003580 return libName
3581}
3582
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003583func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003584 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003585 ccDepModule, _ := ccDep.(*Module)
3586 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003587 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003588
Justin Yuncbca3732021-02-03 19:24:13 +09003589 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003590 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003591 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003592 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003593
Ivan Lozanod1dec542021-05-26 15:33:11 -04003594 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003595 }
3596 }
3597
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003598 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3599 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003600 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3601 // core module instead.
3602 return libName
Kiyoung Kimaa394802024-01-08 12:55:45 +09003603 } else if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003604 // The vendor and product modules in Make will have been renamed to not conflict with the
3605 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003606 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003607 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003608 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003609 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003610 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003611 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003612 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003613 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003614 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003615 } else {
3616 return libName
3617 }
3618}
3619
Colin Crossca860ac2016-01-04 14:34:37 -08003620func (c *Module) InstallInData() bool {
3621 if c.installer == nil {
3622 return false
3623 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003624 return c.installer.inData()
3625}
3626
3627func (c *Module) InstallInSanitizerDir() bool {
3628 if c.installer == nil {
3629 return false
3630 }
3631 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003632 return true
3633 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003634 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003635}
3636
Yifan Hong1b3348d2020-01-21 15:53:22 -08003637func (c *Module) InstallInRamdisk() bool {
3638 return c.InRamdisk()
3639}
3640
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003641func (c *Module) InstallInVendorRamdisk() bool {
3642 return c.InVendorRamdisk()
3643}
3644
Jiyong Parkf9332f12018-02-01 00:54:12 +09003645func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003646 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003647}
3648
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003649func (c *Module) MakeUninstallable() {
3650 if c.installer == nil {
3651 c.ModuleBase.MakeUninstallable()
3652 return
3653 }
3654 c.installer.makeUninstallable(c)
3655}
3656
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003657func (c *Module) HostToolPath() android.OptionalPath {
3658 if c.installer == nil {
3659 return android.OptionalPath{}
3660 }
3661 return c.installer.hostToolPath()
3662}
3663
Nan Zhangd4e641b2017-07-12 12:55:28 -07003664func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3665 return c.outputFile
3666}
3667
Colin Cross41955e82019-05-29 14:40:35 -07003668func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3669 switch tag {
3670 case "":
3671 if c.outputFile.Valid() {
3672 return android.Paths{c.outputFile.Path()}, nil
3673 }
3674 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003675 case "unstripped":
3676 if c.linker != nil {
3677 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3678 }
3679 return nil, nil
Wei Li5f5d2712023-12-11 15:40:29 -08003680 case "stripped_all":
3681 if c.linker != nil {
3682 return android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), nil
3683 }
3684 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003685 default:
3686 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003687 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003688}
3689
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003690func (c *Module) static() bool {
3691 if static, ok := c.linker.(interface {
3692 static() bool
3693 }); ok {
3694 return static.static()
3695 }
3696 return false
3697}
3698
Jiyong Park379de2f2018-12-19 02:47:14 +09003699func (c *Module) staticBinary() bool {
3700 if static, ok := c.linker.(interface {
3701 staticBinary() bool
3702 }); ok {
3703 return static.staticBinary()
3704 }
3705 return false
3706}
3707
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003708func (c *Module) testBinary() bool {
3709 if test, ok := c.linker.(interface {
3710 testBinary() bool
3711 }); ok {
3712 return test.testBinary()
3713 }
3714 return false
3715}
3716
Jingwen Chen537242c2022-08-24 11:53:27 +00003717func (c *Module) testLibrary() bool {
3718 if test, ok := c.linker.(interface {
3719 testLibrary() bool
3720 }); ok {
3721 return test.testLibrary()
3722 }
3723 return false
3724}
3725
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003726func (c *Module) benchmarkBinary() bool {
3727 if b, ok := c.linker.(interface {
3728 benchmarkBinary() bool
3729 }); ok {
3730 return b.benchmarkBinary()
3731 }
3732 return false
3733}
3734
3735func (c *Module) fuzzBinary() bool {
3736 if f, ok := c.linker.(interface {
3737 fuzzBinary() bool
3738 }); ok {
3739 return f.fuzzBinary()
3740 }
3741 return false
3742}
3743
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003744// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3745func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003746 if h, ok := c.linker.(interface {
3747 header() bool
3748 }); ok {
3749 return h.header()
3750 }
3751 return false
3752}
3753
Ivan Lozanod7586b62021-04-01 09:49:36 -04003754func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003755 if b, ok := c.linker.(interface {
3756 binary() bool
3757 }); ok {
3758 return b.binary()
3759 }
3760 return false
3761}
3762
Justin Yun5e035862021-06-29 20:50:37 +09003763func (c *Module) StaticExecutable() bool {
3764 if b, ok := c.linker.(*binaryDecorator); ok {
3765 return b.static()
3766 }
3767 return false
3768}
3769
Ivan Lozanod7586b62021-04-01 09:49:36 -04003770func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003771 if o, ok := c.linker.(interface {
3772 object() bool
3773 }); ok {
3774 return o.object()
3775 }
3776 return false
3777}
3778
Ivan Lozanof9e21722020-12-02 09:00:51 -05003779func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003780 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003781 if c.IsLlndk() {
3782 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003783 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003784 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003785 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003786 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003787 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003788 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003789 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003790 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003791 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003792 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003793 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003794 return "native:product"
3795 }
Jooyung Han38002912019-05-16 04:01:54 +09003796 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003797 } else if c.InRamdisk() {
3798 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003799 } else if c.InVendorRamdisk() {
3800 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003801 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003802 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003803 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003804 return "native:ndk:none:none"
3805 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3806 //family, link := getNdkStlFamilyAndLinkType(c)
3807 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003808 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003809 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003810 } else {
3811 return "native:platform"
3812 }
3813}
3814
Jiyong Park9d452992018-10-03 00:38:19 +09003815// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003816// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003817func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003818 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003819 // Stub libs and prebuilt libs in a versioned SDK are not
3820 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003821 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003822 } else if _, ok := c.linker.(testPerSrc); ok {
3823 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003824 }
3825 return false
3826}
3827
Jiyong Parka90ca002019-10-07 15:47:24 +09003828func (c *Module) AvailableFor(what string) bool {
3829 if linker, ok := c.linker.(interface {
3830 availableFor(string) bool
3831 }); ok {
3832 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3833 } else {
3834 return c.ApexModuleBase.AvailableFor(what)
3835 }
3836}
3837
Jiyong Park62304bb2020-04-13 16:19:48 +09003838func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003839 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003840}
3841
Paul Duffin0cb37b92020-03-04 14:52:46 +00003842func (c *Module) EverInstallable() bool {
3843 return c.installer != nil &&
3844 // Check to see whether the module is actually ever installable.
3845 c.installer.everInstallable()
3846}
3847
Ivan Lozanod7586b62021-04-01 09:49:36 -04003848func (c *Module) PreventInstall() bool {
3849 return c.Properties.PreventInstall
3850}
3851
3852func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003853 if c.library != nil {
3854 if i := c.library.installable(); i != nil {
3855 return i
3856 }
3857 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003858 return c.Properties.Installable
3859}
3860
3861func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003862 ret := c.EverInstallable() &&
3863 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003864 proptools.BoolDefault(c.Installable(), true) &&
3865 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003866
3867 // The platform variant doesn't need further condition. Apex variants however might not
3868 // be installable because it will likely to be included in the APEX and won't appear
3869 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003870 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003871 return ret
3872 }
3873
3874 // Special case for modules that are configured to be installed to /data, which includes
3875 // test modules. For these modules, both APEX and non-APEX variants are considered as
3876 // installable. This is because even the APEX variants won't be included in the APEX, but
3877 // will anyway be installed to /data/*.
3878 // See b/146995717
3879 if c.InstallInData() {
3880 return ret
3881 }
3882
3883 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003884}
3885
Logan Chien41eabe62019-04-10 13:33:58 +08003886func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3887 if c.linker != nil {
3888 if library, ok := c.linker.(*libraryDecorator); ok {
3889 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3890 }
3891 }
3892}
3893
Jiyong Park45bf82e2020-12-15 22:29:02 +09003894var _ android.ApexModule = (*Module)(nil)
3895
3896// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003897func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003898 depTag := ctx.OtherModuleDependencyTag(dep)
3899 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3900
3901 if cc, ok := dep.(*Module); ok {
3902 if cc.HasStubsVariants() {
3903 if isLibDepTag && libDepTag.shared() {
3904 // dynamic dep to a stubs lib crosses APEX boundary
3905 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003906 }
Colin Cross6e511a92020-07-27 21:26:48 -07003907 if IsRuntimeDepTag(depTag) {
3908 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003909 return false
3910 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003911 }
Zhijun Heec285872021-04-24 10:47:08 -07003912 if cc.IsLlndk() {
3913 return false
3914 }
Colin Crossaac32222020-07-29 12:51:56 -07003915 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003916 // shared_lib dependency from a static lib is considered as crossing
3917 // the APEX boundary because the dependency doesn't actually is
3918 // linked; the dependency is used only during the compilation phase.
3919 return false
3920 }
Jiyong Parke3867542020-12-03 17:28:25 +09003921
3922 if isLibDepTag && libDepTag.excludeInApex {
3923 return false
3924 }
Colin Cross6e511a92020-07-27 21:26:48 -07003925 }
Colin Crossc1b36442021-05-06 13:42:48 -07003926 if depTag == stubImplDepTag {
3927 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003928 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003929 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003930 if depTag == staticVariantTag {
3931 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3932 // actually mean that the static lib (and its dependencies) are copied into the
3933 // APEX.
3934 return false
3935 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003936 return true
3937}
3938
Jiyong Park45bf82e2020-12-15 22:29:02 +09003939// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003940func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3941 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003942 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3943 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3944 return nil
3945 }
Jooyung Han749dc692020-04-15 11:03:39 +09003946 // We don't check for prebuilt modules
3947 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3948 return nil
3949 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003950
Jooyung Han749dc692020-04-15 11:03:39 +09003951 minSdkVersion := c.MinSdkVersion()
3952 if minSdkVersion == "apex_inherit" {
3953 return nil
3954 }
3955 if minSdkVersion == "" {
3956 // JNI libs within APK-in-APEX fall into here
3957 // Those are okay to set sdk_version instead
3958 // We don't have to check if this is a SDK variant because
3959 // non-SDK variant resets sdk_version, which works too.
3960 minSdkVersion = c.SdkVersion()
3961 }
Dan Albertc8060532020-07-22 22:32:17 -07003962 if minSdkVersion == "" {
3963 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3964 }
3965 // Not using nativeApiLevelFromUser because the context here is not
3966 // necessarily a native context.
3967 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003968 if err != nil {
3969 return err
3970 }
Dan Albertc8060532020-07-22 22:32:17 -07003971
Colin Cross8ca61c12022-10-06 21:00:14 -07003972 // A dependency only needs to support a min_sdk_version at least
3973 // as high as the api level that the architecture was introduced in.
3974 // This allows introducing new architectures in the platform that
3975 // need to be included in apexes that normally require an older
3976 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003977 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003978 if sdkVersion.LessThan(minApiForArch) {
3979 sdkVersion = minApiForArch
3980 }
3981
Dan Albertc8060532020-07-22 22:32:17 -07003982 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003983 return fmt.Errorf("newer SDK(%v)", ver)
3984 }
3985 return nil
3986}
3987
Paul Duffinb5769c12021-05-12 16:16:51 +01003988// Implements android.ApexModule
3989func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3990 // stub libraries and native bridge libraries are always available to platform
3991 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3992}
3993
Jooyung Han91f92032022-02-04 12:36:33 +09003994// Overrides android.ApexModuleBase.UniqueApexVariations
3995func (c *Module) UniqueApexVariations() bool {
3996 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3997 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3998 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09003999 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09004000 return c.UseVndk() && c.IsVndk()
4001}
4002
Inseob Kima1888ce2022-10-04 14:42:02 +09004003func (c *Module) overriddenModules() []string {
4004 if o, ok := c.linker.(overridable); ok {
4005 return o.overriddenModules()
4006 }
4007 return nil
4008}
4009
Rob Seymour925aa092021-08-10 20:42:03 +00004010var _ snapshot.RelativeInstallPath = (*Module)(nil)
4011
Liz Kammer35ca77e2021-12-22 15:31:40 -05004012type moduleType int
4013
4014const (
4015 unknownType moduleType = iota
4016 binary
4017 object
4018 fullLibrary
4019 staticLibrary
4020 sharedLibrary
4021 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00004022 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00004023 ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00004024 ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05004025)
4026
4027func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00004028 if c.testBinary() {
4029 // testBinary is also a binary, so this comes before the c.Binary()
4030 // conditional. A testBinary has additional implicit dependencies and
4031 // other test-only semantics.
4032 return testBin
4033 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004034 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004035 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004036 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00004037 } else if c.testLibrary() {
4038 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
4039 // will let them add implicit compile deps on gtest, for example.
4040 //
Liz Kammerefc51d92023-04-21 15:11:25 -04004041 // For now, treat them as regular libraries.
4042 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004043 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05004044 static := false
4045 shared := false
4046 if library, ok := c.linker.(*libraryDecorator); ok {
4047 static = library.MutatedProperties.BuildStatic
4048 shared = library.MutatedProperties.BuildShared
4049 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
4050 static = library.MutatedProperties.BuildStatic
4051 shared = library.MutatedProperties.BuildShared
4052 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004053 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004054 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004055 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004056 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004057 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004058 return staticLibrary
4059 }
4060 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00004061 } else if c.isNDKStubLibrary() {
4062 return ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00004063 } else if c.IsNdkPrebuiltStl() {
4064 return ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05004065 }
4066 return unknownType
4067}
4068
Colin Crosscfad1192015-11-02 16:43:11 -08004069// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004070type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004071 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004072 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004073 android.ApexModuleBase
LaMont Jonesafe7baf2024-01-09 22:47:39 +00004074
4075 // Aconfig files for all transitive deps. Also exposed via TransitiveDeclarationsInfo
4076 mergedAconfigFiles map[string]android.Paths
Colin Crosscfad1192015-11-02 16:43:11 -08004077}
4078
Patrice Arrudac249c712019-03-19 17:00:29 -07004079// cc_defaults provides a set of properties that can be inherited by other cc
4080// modules. A module can use the properties from a cc_defaults using
4081// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4082// merged (when possible) by prepending the default module's values to the
4083// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004084func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004085 return DefaultsFactory()
4086}
4087
Colin Cross36242852017-06-23 15:06:31 -07004088func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004089 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004090
Colin Cross36242852017-06-23 15:06:31 -07004091 module.AddProperties(props...)
4092 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004093 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004094 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004095 &BaseCompilerProperties{},
4096 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004097 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004098 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004099 &StaticProperties{},
4100 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004101 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004102 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004103 &TestLinkerProperties{},
4104 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004105 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004106 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004107 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004108 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004109 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004110 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004111 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004112 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004113 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004114 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004115 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004116 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004117 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00004118 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004119 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004120 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4121 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004122 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004123 )
Colin Crosscfad1192015-11-02 16:43:11 -08004124
Jooyung Hancc372c52019-09-25 15:18:44 +09004125 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004126
4127 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004128}
4129
Jiyong Park2286afd2020-06-16 21:58:53 +09004130func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004131 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004132}
4133
Kiyoung Kim51279d32022-08-24 14:10:46 +09004134func (c *Module) isImportedApiLibrary() bool {
4135 _, ok := c.linker.(*apiLibraryDecorator)
4136 return ok
4137}
4138
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004139func kytheExtractAllFactory() android.Singleton {
4140 return &kytheExtractAllSingleton{}
4141}
4142
4143type kytheExtractAllSingleton struct {
4144}
4145
4146func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4147 var xrefTargets android.Paths
4148 ctx.VisitAllModules(func(module android.Module) {
4149 if ccModule, ok := module.(xref); ok {
4150 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4151 }
4152 })
4153 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4154 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004155 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004156 }
4157}
4158
Jihoon Kangf78a8902022-09-01 22:47:07 +00004159func (c *Module) Partition() string {
4160 if p, ok := c.installer.(interface {
4161 getPartition() string
4162 }); ok {
4163 return p.getPartition()
4164 }
4165 return ""
4166}
4167
Colin Cross06a931b2015-10-28 17:23:31 -07004168var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004169var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004170var BoolPtr = proptools.BoolPtr
4171var String = proptools.String
4172var StringPtr = proptools.StringPtr