blob: 8f9285ab1c508865124a4188a8465df4dea04333 [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"
Colin Cross3f40fa42015-01-30 17:27:36 -080038)
39
Colin Cross463a90e2015-06-17 14:20:06 -070040func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000041 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070042
Inseob Kim3b244062023-07-11 13:31:36 +090043 pctx.Import("android/soong/android")
Paul Duffin036e7002019-12-19 19:16:28 +000044 pctx.Import("android/soong/cc/config")
45}
46
47func RegisterCCBuildComponents(ctx android.RegistrationContext) {
48 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
49
50 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000051 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090052 ctx.BottomUp("vndk", VndkMutator).Parallel()
Kiyoung Kim973cb6f2024-04-29 14:14:53 +090053 ctx.BottomUp("llndk", llndkMutator).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 Crossd38feb02024-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
Ivan Lozano0a468a42024-05-13 21:03:34 -0400103 Rlibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700104
Colin Cross3e5e7782022-06-17 22:17:05 +0000105 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
106 // prevent automatically exporting symbols.
107 UnexportedStaticLibs []string
108
Chris Parsons79d66a52020-06-05 17:26:16 -0400109 // Used for data dependencies adjacent to tests
110 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700111 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400112
Yo Chiang219968c2020-09-22 18:45:04 +0800113 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
114 SystemSharedLibs []string
115
Vinh Tran367d89d2023-04-28 11:21:25 -0400116 // Used by DepMutator to pass aidl_library modules to aidl compiler
117 AidlLibs []string
118
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500119 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800120 StaticUnwinderIfLegacy bool
121
Colin Cross5950f382016-12-13 12:50:57 -0800122 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700123
Colin Cross81413472016-04-11 14:37:39 -0700124 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700125
Dan Willemsenb40aab62016-04-20 14:21:14 -0700126 GeneratedSources []string
127 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900128 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700129
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700130 ReexportGeneratedHeaders []string
131
Colin Crossc465efd2021-06-11 18:00:04 -0700132 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700133
134 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700135 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900136
137 // List of libs that need to be excluded for APEX variant
138 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900139 // List of libs that need to be excluded for non-APEX variant
140 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800141
142 // LLNDK headers for the ABI checker to check LLNDK implementation library.
143 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
144 // The core variant cannot depend on the vendor variant because of the order of CreateVariations.
145 // Instead, the LLNDK implementation depends on the LLNDK header libs.
146 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700147}
148
Ivan Lozano0a468a42024-05-13 21:03:34 -0400149// A struct which to collect flags for rlib dependencies
150type RustRlibDep struct {
151 LibPath android.Path // path to the rlib
152 LinkDirs []string // flags required for dependency (e.g. -L flags)
153 CrateName string // crateNames associated with rlibDeps
154}
155
156func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
157 return a.LibPath == b.LibPath
158}
159
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500160// PathDeps is a struct containing file paths to dependencies of a module.
161// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
162// It's used to construct flags for various build statements (such as for compiling and linking).
163// It is then passed to module decorator functions responsible for registering build statements
164// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800165type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700166 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900167 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700168 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900169 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700170 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700171 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400172 // Paths and crateNames for RustStaticLib dependencies
173 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700174
Colin Cross0de8a1e2020-09-18 14:15:30 -0700175 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossc85750b2022-04-21 12:50:51 -0700176 TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700177
Colin Cross26c34ed2016-09-30 17:10:16 -0700178 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100179 Objs Objects
180 // Paths to .o files in dependencies that provide them. Note that these lists
181 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800182 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700183 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700184
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100185 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
186 // the libs from all whole_static_lib dependencies.
187 WholeStaticLibsFromPrebuilts android.Paths
188
Colin Cross26c34ed2016-09-30 17:10:16 -0700189 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700190 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900191 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700192
Inseob Kimd110f872019-12-06 13:15:38 +0900193 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000194 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900195 IncludeDirs android.Paths
196 SystemIncludeDirs android.Paths
197 ReexportedDirs android.Paths
198 ReexportedSystemDirs android.Paths
199 ReexportedFlags []string
200 ReexportedGeneratedHeaders android.Paths
201 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400202 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700203
Colin Cross26c34ed2016-09-30 17:10:16 -0700204 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700205 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700206
Dan Willemsena0790e32018-10-12 00:24:23 -0700207 // Path to the dynamic linker binary
208 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700209
210 // For Darwin builds, the path to the second architecture's output that should
211 // be combined with this architectures's output into a FAT MachO file.
212 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400213
214 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
215 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800216
217 // LLNDK headers for the ABI checker to check LLNDK implementation library.
218 LlndkIncludeDirs android.Paths
219 LlndkSystemIncludeDirs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700220}
221
Colin Cross4af21ed2019-11-04 09:37:55 -0800222// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
223// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
224// command line so they can be overridden by the local module flags).
225type LocalOrGlobalFlags struct {
226 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700227 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800228 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700229 CFlags []string // Flags that apply to C and C++ source files
230 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
231 ConlyFlags []string // Flags that apply to C source files
232 CppFlags []string // Flags that apply to C++ source files
233 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700234 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800235}
236
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500237// Flags contains various types of command line flags (and settings) for use in building build
238// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800239type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500240 // Local flags (which individual modules are responsible for). These may override global flags.
241 Local LocalOrGlobalFlags
242 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700243 Global LocalOrGlobalFlags
244 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800245
246 aidlFlags []string // Flags that apply to aidl source files
247 rsFlags []string // Flags that apply to renderscript source files
248 libFlags []string // Flags to add libraries early to the link order
249 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
250 TidyFlags []string // Flags that apply to clang-tidy
251 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700252
Colin Crossc3199482017-03-30 15:03:04 -0700253 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800254 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700255 SystemIncludeFlags []string
256
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800257 Toolchain config.Toolchain
258 Tidy bool // True if ninja .tidy rules should be generated.
259 NeedTidyFiles bool // True if module link should depend on .tidy files
260 GcovCoverage bool // True if coverage files should be generated.
261 SAbiDump bool // True if header abi dumps should be generated.
262 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800263 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800264
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500265 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800266 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500267 // The target-device system path to the dynamic linker.
268 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800269
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700270 CFlagsDeps android.Paths // Files depended on by compiler flags
271 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800272
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500273 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700274 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800275
Colin Cross19878da2019-03-28 14:45:07 -0700276 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700277 protoC bool // Whether to use C instead of C++
278 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700279
280 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200281 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700282}
283
Colin Crossca860ac2016-01-04 14:34:37 -0800284// Properties used to compile all C or C++ modules
285type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700286 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800287 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700288
Yi Kong5786f5c2024-05-28 02:22:34 +0900289 // Aggresively trade performance for smaller binary size.
290 // This should only be used for on-device binaries that are rarely executed and not
291 // performance critical.
292 Optimize_for_size *bool `android:"arch_variant"`
293
Jiyong Parkb35a8192020-08-10 15:59:36 +0900294 // The API level that this module is built against. The APIs of this API level will be
295 // visible at build time, but use of any APIs newer than min_sdk_version will render the
296 // module unloadable on older devices. In the future it will be possible to weakly-link new
297 // APIs, making the behavior match Java: such modules will load on older devices, but
298 // calling new APIs on devices that do not support them will result in a crash.
299 //
300 // This property has the same behavior as sdk_version does for Java modules. For those
301 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
302 // does for Java code.
303 //
304 // In addition, setting this property causes two variants to be built, one for the platform
305 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800306 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700307
Jiyong Parkb35a8192020-08-10 15:59:36 +0900308 // Minimum OS API level supported by this C or C++ module. This property becomes the value
309 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
310 // this property is also used to ensure that the min_sdk_version of the containing module is
311 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
312 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
313 // min_sdk_version of the containing APEX. When the module
314 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900315 Min_sdk_version *string
316
Colin Crossc511bc52020-04-07 16:50:32 +0000317 // If true, always create an sdk variant and don't create a platform variant.
318 Sdk_variant_only *bool
319
Jiyong Parkde866cb2018-12-07 23:08:36 +0900320 AndroidMkSharedLibs []string `blueprint:"mutated"`
321 AndroidMkStaticLibs []string `blueprint:"mutated"`
Ivan Lozano0a468a42024-05-13 21:03:34 -0400322 AndroidMkRlibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900323 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
324 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700325 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900326 HideFromMake bool `blueprint:"mutated"`
327 PreventInstall bool `blueprint:"mutated"`
328 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700329
Yo Chiang219968c2020-09-22 18:45:04 +0800330 // Set by DepsMutator.
331 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
332
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900333 // The name of the image this module is built for
334 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200335
336 // The VNDK version this module is built against. If empty, the module is not
337 // build against the VNDK.
338 VndkVersion string `blueprint:"mutated"`
339
340 // Suffix for the name of Android.mk entries generated by this module
341 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800342
343 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
344 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900345 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900346
Yifan Hong39143a92020-10-26 12:43:12 -0700347 // Make this module available when building for ramdisk.
348 // On device without a dedicated recovery partition, the module is only
349 // available after switching root into
350 // /first_stage_ramdisk. To expose the module before switching root, install
351 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800352 Ramdisk_available *bool
353
Yifan Hong39143a92020-10-26 12:43:12 -0700354 // Make this module available when building for vendor ramdisk.
355 // On device without a dedicated recovery partition, the module is only
356 // available after switching root into
357 // /first_stage_ramdisk. To expose the module before switching root, install
358 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700359 Vendor_ramdisk_available *bool
360
Jiyong Parkf9332f12018-02-01 00:54:12 +0900361 // Make this module available when building for recovery
362 Recovery_available *bool
363
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200364 // Used by imageMutator, set by ImageMutatorBegin()
365 CoreVariantNeeded bool `blueprint:"mutated"`
366 RamdiskVariantNeeded bool `blueprint:"mutated"`
367 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
368 RecoveryVariantNeeded bool `blueprint:"mutated"`
369
370 // A list of variations for the "image" mutator of the form
371 //<image name> '.' <version char>, for example, 'vendor.S'
372 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900373
374 // Allows this module to use non-APEX version of libraries. Useful
375 // for building binaries that are started before APEXes are activated.
376 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900377
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000378 // Allows this module to be included in CMake release snapshots to be built outside of Android
379 // build system and source tree.
380 Cmake_snapshot_supported *bool
381
Colin Cross1bc94122021-10-28 13:25:54 -0700382 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000383
384 // Set by factories of module types that can only be referenced from variants compiled against
385 // the SDK.
386 AlwaysSdk bool `blueprint:"mutated"`
387
388 // Variant is an SDK variant created by sdkMutator
389 IsSdkVariant bool `blueprint:"mutated"`
390 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
391 // variant to have a ".sdk" suffix.
392 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700393
Jiyong Park46a512f2020-12-04 18:02:13 +0900394 // List of APEXes that this module has private access to for testing purpose. The module
395 // can depend on libraries that are not exported by the APEXes and use private symbols
396 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000397 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800398
399 Target struct {
400 Platform struct {
401 // List of modules required by the core variant.
402 Required []string `android:"arch_variant"`
403
404 // List of modules not required by the core variant.
405 Exclude_required []string `android:"arch_variant"`
406 } `android:"arch_variant"`
407
408 Recovery struct {
409 // List of modules required by the recovery variant.
410 Required []string `android:"arch_variant"`
411
412 // List of modules not required by the recovery variant.
413 Exclude_required []string `android:"arch_variant"`
414 } `android:"arch_variant"`
415 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700416}
417
418type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900419 // whether this module should be allowed to be directly depended by other
420 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900421 // If set to true, two variants will be built separately, one like
422 // normal, and the other limited to the set of libraries and headers
423 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700424 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900425 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700426 // so it shouldn't have any unversioned runtime dependencies, or
427 // make assumptions about the system that may not be true in the
428 // future.
429 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900430 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900431 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900432 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900433 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900434 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700435 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
436 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900437
Justin Yunebcf0c52021-01-08 18:00:19 +0900438 // This is the same as the "vendor_available" except that the install path
439 // of the vendor variant is /odm or /vendor/odm.
440 // By replacing "vendor_available: true" with "odm_available: true", the
441 // module will install its vendor variant to the /odm partition or /vendor/odm.
442 // As the modules with "odm_available: true" still create the vendor variants,
443 // they can link to the other vendor modules as the vendor_available modules do.
444 // Also, the vendor modules can link to odm_available modules.
445 //
446 // It may not be used for VNDK modules.
447 Odm_available *bool
448
Justin Yun63e9ec72020-10-29 16:49:43 +0900449 // whether this module should be allowed to be directly depended by other
450 // modules with `product_specific: true` or `product_available: true`.
451 // If set to true, an additional product variant will be built separately
452 // that is limited to the set of libraries and headers that are exposed to
453 // /product modules.
454 //
455 // The product variant may be used with a different (newer) /system,
456 // so it shouldn't have any unversioned runtime dependencies, or
457 // make assumptions about the system that may not be true in the
458 // future.
459 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900460 // If set to false, this module becomes inaccessible from /product modules.
461 //
462 // Different from the 'vendor_available' property, the modules with
463 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
464 // library without 'product_available' may not be depended on by any other
465 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900466 //
467 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
468 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
469 Product_available *bool
470
Jiyong Park5fb8c102018-04-09 12:03:06 +0900471 // whether this module is capable of being loaded with other instance
472 // (possibly an older version) of the same module in the same process.
473 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
474 // can be double loaded in a vendor process if the library is also a
475 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
476 // explicitly marked as `double_loadable: true` by the owner, or the dependency
477 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
478 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800479
480 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
481 IsLLNDK bool `blueprint:"mutated"`
482
Colin Cross78212242021-01-06 14:51:30 -0800483 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
484 IsVNDKCore bool `blueprint:"mutated"`
485
486 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
487 IsVNDKSP bool `blueprint:"mutated"`
488
489 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
490 // module sets the llndk.private property.
491 IsVNDKPrivate bool `blueprint:"mutated"`
492
493 // IsVNDKProduct is set if a VNDK module sets the product_available property.
494 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700495
496 // IsVendorPublicLibrary is set for the core and product variants of a library that has
497 // vendor_public_library stubs.
498 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800499}
500
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500501// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
502// to understanding details about the type of the current module.
503// For example, one might call these functions to determine whether the current module is a static
504// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800505type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800506 static() bool
507 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700508 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800509 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900510 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900511 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900512 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700513 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900514 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700515 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800516 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900517 minSdkVersion() string
518 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700519 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700520 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800521 IsLlndk() bool
522 IsLlndkPublic() bool
523 isImplementationForLLNDKPublic() bool
524 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900525 isVndk() bool
526 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500527 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700528 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900529 inProduct() bool
530 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800531 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700532 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900533 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900534 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700535 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700536 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800537 getVndkExtendsModuleName() string
Colin Cross3513fb12024-01-24 14:44:47 -0800538 isAfdoCompile(ctx ModuleContext) bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000539 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800540 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900541 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800542 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800543 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800544 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700545 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700546 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900547 bootstrap() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700548 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700549 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800550 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800551 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800552 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800553 notInPlatform() bool
Yi Kong5786f5c2024-05-28 02:22:34 +0900554 optimizeForSize() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800555}
556
557type SharedFlags struct {
558 numSharedFlags int
559 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800560}
561
562type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700563 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800564 ModuleContextIntf
565}
566
567type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700568 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800569 ModuleContextIntf
570}
571
Colin Cross37047f12016-12-13 17:06:13 -0800572type DepsContext interface {
573 android.BottomUpMutatorContext
574 ModuleContextIntf
575}
576
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500577// feature represents additional (optional) steps to building cc-related modules, such as invocation
578// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800579type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800580 flags(ctx ModuleContext, flags Flags) Flags
581 props() []interface{}
582}
583
Joe Onorato37f900c2023-07-18 16:58:16 -0700584// Information returned from Generator about the source code it's generating
585type GeneratedSource struct {
586 IncludeDirs android.Paths
587 Sources android.Paths
588 Headers android.Paths
589 ReexportedDirs android.Paths
590}
591
592// generator allows injection of generated code
593type Generator interface {
594 GeneratorProps() []interface{}
595 GeneratorInit(ctx BaseModuleContext)
596 GeneratorDeps(ctx DepsContext, deps Deps) Deps
597 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
598 GeneratorSources(ctx ModuleContext) GeneratedSource
599 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
600}
601
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500602// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500603// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800604type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700605 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800606 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800607 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700608 compilerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000609 baseCompilerProps() BaseCompilerProperties
Colin Cross42742b82016-08-01 13:20:05 -0700610
Colin Cross76fada02016-07-27 10:31:13 -0700611 appendCflags([]string)
612 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700613 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800614}
615
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500616// linker is the interface for a linker decorator object. Individual module types can provide
617// their own implementation for this decorator, and thus specify custom logic regarding build
618// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800619type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700620 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800621 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700622 linkerFlags(ctx ModuleContext, flags Flags) Flags
623 linkerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000624 baseLinkerProps() BaseLinkerProperties
Ivan Lozanobd721262018-11-27 14:33:03 -0800625 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700626
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700627 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700628 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900629 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800630 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700631
632 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900633 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000634
635 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000636 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800637
638 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000639}
640
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500641// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000642type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500643 sharedLibs []string
644 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
645 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700646 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800647}
648
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500649// installer is the interface for an installer helper object. This helper is responsible for
650// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800651type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700652 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700653 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000654 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800655 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700656 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700657 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900658 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000659 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900660 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800661}
662
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800663type xref interface {
664 XrefCcFiles() android.Paths
665}
666
Inseob Kima1888ce2022-10-04 14:42:02 +0900667type overridable interface {
668 overriddenModules() []string
669}
670
Colin Cross6e511a92020-07-27 21:26:48 -0700671type libraryDependencyKind int
672
673const (
674 headerLibraryDependency = iota
675 sharedLibraryDependency
676 staticLibraryDependency
Ivan Lozano0a468a42024-05-13 21:03:34 -0400677 rlibLibraryDependency
Colin Cross6e511a92020-07-27 21:26:48 -0700678)
679
680func (k libraryDependencyKind) String() string {
681 switch k {
682 case headerLibraryDependency:
683 return "headerLibraryDependency"
684 case sharedLibraryDependency:
685 return "sharedLibraryDependency"
686 case staticLibraryDependency:
687 return "staticLibraryDependency"
Ivan Lozano0a468a42024-05-13 21:03:34 -0400688 case rlibLibraryDependency:
689 return "rlibLibraryDependency"
Colin Cross6e511a92020-07-27 21:26:48 -0700690 default:
691 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
692 }
693}
694
695type libraryDependencyOrder int
696
697const (
698 earlyLibraryDependency = -1
699 normalLibraryDependency = 0
700 lateLibraryDependency = 1
701)
702
703func (o libraryDependencyOrder) String() string {
704 switch o {
705 case earlyLibraryDependency:
706 return "earlyLibraryDependency"
707 case normalLibraryDependency:
708 return "normalLibraryDependency"
709 case lateLibraryDependency:
710 return "lateLibraryDependency"
711 default:
712 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
713 }
714}
715
716// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
717// tags that have a set of predefined tag objects that are reused for each dependency, a
718// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
719// That means that comparing a libraryDependencyTag for equality will only be equal if all
720// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
721// then check individual metadata fields instead.
722type libraryDependencyTag struct {
723 blueprint.BaseDependencyTag
724
725 // These are exported so that fmt.Printf("%#v") can call their String methods.
726 Kind libraryDependencyKind
727 Order libraryDependencyOrder
728
729 wholeStatic bool
730
731 reexportFlags bool
732 explicitlyVersioned bool
733 dataLib bool
734 ndk bool
735
736 staticUnwinder bool
737
738 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900739
Cindy Zhou18417cb2020-12-10 07:12:38 -0800740 // Whether or not this dependency should skip the apex dependency check
741 skipApexAllowedDependenciesCheck bool
742
Jiyong Parke3867542020-12-03 17:28:25 +0900743 // Whether or not this dependency has to be followed for the apex variants
744 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900745 // Whether or not this dependency has to be followed for the non-apex variants
746 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000747
748 // If true, don't automatically export symbols from the static library into a shared library.
749 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700750}
751
752// header returns true if the libraryDependencyTag is tagging a header lib dependency.
753func (d libraryDependencyTag) header() bool {
754 return d.Kind == headerLibraryDependency
755}
756
757// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
758func (d libraryDependencyTag) shared() bool {
759 return d.Kind == sharedLibraryDependency
760}
761
762// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
763func (d libraryDependencyTag) static() bool {
764 return d.Kind == staticLibraryDependency
765}
766
Ivan Lozano0a468a42024-05-13 21:03:34 -0400767// rlib returns true if the libraryDependencyTag is tagging an rlib dependency.
768func (d libraryDependencyTag) rlib() bool {
769 return d.Kind == rlibLibraryDependency
770}
771
Colin Cross65cb3142021-12-10 23:05:02 +0000772func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
773 if d.shared() {
774 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
775 }
776 return nil
777}
778
779var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
780
Colin Crosse9fe2942020-11-10 18:12:15 -0800781// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
782// binaries or other shared libraries are installed as dependencies.
783func (d libraryDependencyTag) InstallDepNeeded() bool {
784 return d.shared()
785}
786
787var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
788
Yu Liu67a28422024-03-05 00:36:31 +0000789func (d libraryDependencyTag) PropagateAconfigValidation() bool {
790 return d.static()
791}
792
793var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
794
Colin Crosse9fe2942020-11-10 18:12:15 -0800795// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700796// libraryDependencyTag. Each tag object is created globally and reused for multiple
797// dependencies (although since the object contains no references, assigning a tag to a
798// variable and modifying it will not modify the original). Users can compare the tag
799// returned by ctx.OtherModuleDependencyTag against the global original
800type dependencyTag struct {
801 blueprint.BaseDependencyTag
802 name string
803}
804
Colin Crosse9fe2942020-11-10 18:12:15 -0800805// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
806// libraryDependencyTag, but where the dependency needs to be installed when the parent is
807// installed.
808type installDependencyTag struct {
809 blueprint.BaseDependencyTag
810 android.InstallAlwaysNeededDependencyTag
811 name string
812}
813
Colin Crossc99deeb2016-04-11 15:06:20 -0700814var (
Colin Cross6e511a92020-07-27 21:26:48 -0700815 genSourceDepTag = dependencyTag{name: "gen source"}
816 genHeaderDepTag = dependencyTag{name: "gen header"}
817 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
818 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900819 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700820 reuseObjTag = dependencyTag{name: "reuse objects"}
821 staticVariantTag = dependencyTag{name: "static variant"}
822 vndkExtDepTag = dependencyTag{name: "vndk extends"}
823 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700824 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800825 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700826 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700827 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000828 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500829 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400830 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800831 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700832)
833
Roland Levillainf89cd092019-07-29 16:22:59 +0100834func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700835 ccLibDepTag, ok := depTag.(libraryDependencyTag)
836 return ok && ccLibDepTag.shared()
837}
838
839func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
840 ccLibDepTag, ok := depTag.(libraryDependencyTag)
841 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100842}
843
Zach Johnson3df4e632020-11-06 11:56:27 -0800844func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
845 ccLibDepTag, ok := depTag.(libraryDependencyTag)
846 return ok && ccLibDepTag.header()
847}
848
Roland Levillainf89cd092019-07-29 16:22:59 +0100849func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800850 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100851}
852
853func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700854 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100855 return ok && ccDepTag == testPerSrcDepTag
856}
857
Colin Crossca860ac2016-01-04 14:34:37 -0800858// Module contains the properties and members used by all C/C++ module types, and implements
859// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500860// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
861// interface.
862//
863// To define a C/C++ related module, construct a new Module object and point its delegates to
864// type-specific structs. These delegates will be invoked to register module-specific build
865// statements which may be unique to the module type. For example, module.compiler.compile() should
866// be defined so as to register build statements which are responsible for compiling the module.
867//
868// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
869// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
870// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
871// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800872type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700873 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700874
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700875 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700876 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700877 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700878
Colin Crossca860ac2016-01-04 14:34:37 -0800879 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000880 hod android.HostOrDeviceSupported
881 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000882 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700883
Paul Duffina0843f62019-12-13 19:50:38 +0000884 // Allowable SdkMemberTypes of this module type.
885 sdkMemberTypes []android.SdkMemberType
886
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500887 // decorator delegates, initialize before calling Init
888 // these may contain module-specific implementations, and effectively allow for custom
889 // type-specific logic. These members may reference different objects or the same object.
890 // Functions of these decorators will be invoked to initialize and register type-specific
891 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800892 generators []Generator
893 compiler compiler
894 linker linker
895 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500896
Spandan Dase12d2522023-09-12 21:42:31 +0000897 features []feature
898 stl *stl
899 sanitize *sanitize
900 coverage *coverage
901 fuzzer *fuzzer
902 sabi *sabi
903 vndkdep *vndkdep
904 lto *lto
905 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000906 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800907
Colin Cross31076b32020-10-23 17:22:06 -0700908 library libraryInterface
909
Colin Cross635c3b02016-05-18 15:37:25 -0700910 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800911
Colin Crossb98c8b02016-07-29 13:44:28 -0700912 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700913
914 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800915
916 // Flags used to compile this module
917 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700918
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800919 // Shared flags among build rules of this module
920 sharedFlags SharedFlags
921
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800922 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700923 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900924
925 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800926 // Kythe (source file indexer) paths for this compilation module
927 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700928 // Object .o file output paths for this compilation module
929 objFiles android.Paths
930 // Tidy .tidy file output paths for this compilation module
931 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900932
933 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700934 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700935
936 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800937
Inseob Kim37e0bb02024-04-29 15:54:44 +0900938 logtagsPaths android.Paths
Colin Crossc472d572015-03-17 15:06:21 -0700939}
940
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200941func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400942 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
943 if b, ok := c.compiler.(*baseCompiler); ok {
944 hasAidl = b.hasSrcExt(".aidl")
945 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
946 hasProto = b.hasSrcExt(".proto")
947 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
948 hasSysprop = b.hasSrcExt(".sysprop")
949 hasWinMsg = b.hasSrcExt(".mc")
950 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
951 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200952 c.AndroidModuleBase().AddJSONData(d)
953 (*d)["Cc"] = map[string]interface{}{
954 "SdkVersion": c.SdkVersion(),
955 "MinSdkVersion": c.MinSdkVersion(),
956 "VndkVersion": c.VndkVersion(),
957 "ProductSpecific": c.ProductSpecific(),
958 "SocSpecific": c.SocSpecific(),
959 "DeviceSpecific": c.DeviceSpecific(),
960 "InProduct": c.InProduct(),
961 "InVendor": c.InVendor(),
962 "InRamdisk": c.InRamdisk(),
963 "InVendorRamdisk": c.InVendorRamdisk(),
964 "InRecovery": c.InRecovery(),
965 "VendorAvailable": c.VendorAvailable(),
966 "ProductAvailable": c.ProductAvailable(),
967 "RamdiskAvailable": c.RamdiskAvailable(),
968 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
969 "RecoveryAvailable": c.RecoveryAvailable(),
970 "OdmAvailable": c.OdmAvailable(),
971 "InstallInData": c.InstallInData(),
972 "InstallInRamdisk": c.InstallInRamdisk(),
973 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
974 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
975 "InstallInRecovery": c.InstallInRecovery(),
976 "InstallInRoot": c.InstallInRoot(),
977 "IsVndk": c.IsVndk(),
978 "IsVndkExt": c.IsVndkExt(),
979 "IsVndkPrivate": c.IsVndkPrivate(),
980 "IsVndkSp": c.IsVndkSp(),
981 "IsLlndk": c.IsLlndk(),
982 "IsLlndkPublic": c.IsLlndkPublic(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200983 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
984 "ApexSdkVersion": c.apexSdkVersion,
985 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400986 "AidlSrcs": hasAidl,
987 "LexSrcs": hasLex,
988 "ProtoSrcs": hasProto,
989 "RenderscriptSrcs": hasRenderscript,
990 "SyspropSrcs": hasSysprop,
991 "WinMsgSrcs": hasWinMsg,
992 "YaccSrsc": hasYacc,
993 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900994 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200995 }
996}
997
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500998func (c *Module) SetPreventInstall() {
999 c.Properties.PreventInstall = true
1000}
1001
1002func (c *Module) SetHideFromMake() {
1003 c.Properties.HideFromMake = true
1004}
1005
Ivan Lozanod7586b62021-04-01 09:49:36 -04001006func (c *Module) HiddenFromMake() bool {
1007 return c.Properties.HideFromMake
1008}
1009
Cole Faust43ddd082024-06-17 12:32:40 -07001010func (c *Module) RequiredModuleNames(ctx android.ConfigAndErrorContext) []string {
1011 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +08001012 if c.ImageVariation().Variation == android.CoreVariation {
1013 required = append(required, c.Properties.Target.Platform.Required...)
1014 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
1015 } else if c.InRecovery() {
1016 required = append(required, c.Properties.Target.Recovery.Required...)
1017 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
1018 }
1019 return android.FirstUniqueStrings(required)
1020}
1021
Ivan Lozano52767be2019-10-18 14:49:46 -07001022func (c *Module) Toc() android.OptionalPath {
1023 if c.linker != nil {
1024 if library, ok := c.linker.(libraryInterface); ok {
1025 return library.toc()
1026 }
1027 }
1028 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
1029}
1030
1031func (c *Module) ApiLevel() string {
1032 if c.linker != nil {
1033 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001034 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001035 }
1036 }
1037 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1038}
1039
1040func (c *Module) Static() bool {
1041 if c.linker != nil {
1042 if library, ok := c.linker.(libraryInterface); ok {
1043 return library.static()
1044 }
1045 }
1046 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1047}
1048
1049func (c *Module) Shared() bool {
1050 if c.linker != nil {
1051 if library, ok := c.linker.(libraryInterface); ok {
1052 return library.shared()
1053 }
1054 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001055
Ivan Lozano52767be2019-10-18 14:49:46 -07001056 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1057}
1058
1059func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001060 if c.stl != nil {
1061 return c.stl.Properties.SelectedStl
1062 }
1063 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001064}
1065
Ivan Lozano52767be2019-10-18 14:49:46 -07001066func (c *Module) NdkPrebuiltStl() bool {
1067 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1068 return true
1069 }
1070 return false
1071}
1072
1073func (c *Module) StubDecorator() bool {
1074 if _, ok := c.linker.(*stubDecorator); ok {
1075 return true
1076 }
1077 return false
1078}
1079
Yi Kong5786f5c2024-05-28 02:22:34 +09001080func (c *Module) OptimizeForSize() bool {
1081 return Bool(c.Properties.Optimize_for_size)
1082}
1083
Ivan Lozano52767be2019-10-18 14:49:46 -07001084func (c *Module) SdkVersion() string {
1085 return String(c.Properties.Sdk_version)
1086}
1087
Artur Satayev480e25b2020-04-27 18:53:18 +01001088func (c *Module) MinSdkVersion() string {
1089 return String(c.Properties.Min_sdk_version)
1090}
1091
Jiyong Park5df7bd32021-08-25 16:18:46 +09001092func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001093 if linker, ok := c.linker.(*objectLinker); ok {
1094 return linker.isCrt()
1095 }
1096 return false
1097}
1098
Jiyong Park5df7bd32021-08-25 16:18:46 +09001099func (c *Module) SplitPerApiLevel() bool {
1100 return c.canUseSdk() && c.isCrt()
1101}
1102
Colin Crossc511bc52020-04-07 16:50:32 +00001103func (c *Module) AlwaysSdk() bool {
1104 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1105}
1106
Ivan Lozano183a3212019-10-18 14:18:45 -07001107func (c *Module) CcLibrary() bool {
1108 if c.linker != nil {
1109 if _, ok := c.linker.(*libraryDecorator); ok {
1110 return true
1111 }
Colin Crossd48fe732020-09-23 20:37:24 -07001112 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1113 return true
1114 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001115 }
1116 return false
1117}
1118
1119func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001120 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001121 return true
1122 }
1123 return false
1124}
1125
Spandan Dase12d2522023-09-12 21:42:31 +00001126func (c *Module) IsNdkPrebuiltStl() bool {
1127 if c.linker == nil {
1128 return false
1129 }
1130 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1131 return true
1132 }
1133 return false
1134}
1135
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001136func (c *Module) RlibStd() bool {
1137 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1138}
1139
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001140func (c *Module) RustLibraryInterface() bool {
1141 return false
1142}
1143
Ivan Lozano0a468a42024-05-13 21:03:34 -04001144func (c *Module) CrateName() string {
1145 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1146}
1147
1148func (c *Module) ExportedCrateLinkDirs() []string {
1149 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1150}
1151
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001152func (c *Module) IsFuzzModule() bool {
1153 if _, ok := c.compiler.(*fuzzBinary); ok {
1154 return true
1155 }
1156 return false
1157}
1158
1159func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1160 return c.FuzzModule
1161}
1162
1163func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1164 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1165 return fuzzer.fuzzPackagedModule
1166 }
1167 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1168}
1169
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001170func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001171 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1172 return fuzzer.sharedLibraries
1173 }
1174 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1175}
1176
Ivan Lozano2b262972019-11-21 12:30:50 -08001177func (c *Module) NonCcVariants() bool {
1178 return false
1179}
1180
Ivan Lozano183a3212019-10-18 14:18:45 -07001181func (c *Module) SetStatic() {
1182 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001183 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001184 library.setStatic()
1185 return
1186 }
1187 }
1188 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1189}
1190
1191func (c *Module) SetShared() {
1192 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001193 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001194 library.setShared()
1195 return
1196 }
1197 }
1198 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1199}
1200
1201func (c *Module) BuildStaticVariant() bool {
1202 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001203 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001204 return library.buildStatic()
1205 }
1206 }
1207 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1208}
1209
1210func (c *Module) BuildSharedVariant() bool {
1211 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001212 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001213 return library.buildShared()
1214 }
1215 }
1216 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1217}
1218
1219func (c *Module) Module() android.Module {
1220 return c
1221}
1222
Jiyong Parkc20eee32018-09-05 22:36:17 +09001223func (c *Module) OutputFile() android.OptionalPath {
1224 return c.outputFile
1225}
1226
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001227func (c *Module) CoverageFiles() android.Paths {
1228 if c.linker != nil {
1229 if library, ok := c.linker.(libraryInterface); ok {
1230 return library.objs().coverageFiles
1231 }
1232 }
1233 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1234}
1235
Ivan Lozano183a3212019-10-18 14:18:45 -07001236var _ LinkableInterface = (*Module)(nil)
1237
Jiyong Park719b4462019-01-13 00:39:51 +09001238func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001239 if c.linker != nil {
1240 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001241 }
1242 return nil
1243}
1244
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001245func (c *Module) CoverageOutputFile() android.OptionalPath {
1246 if c.linker != nil {
1247 return c.linker.coverageOutputFilePath()
1248 }
1249 return android.OptionalPath{}
1250}
1251
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001252func (c *Module) RelativeInstallPath() string {
1253 if c.installer != nil {
1254 return c.installer.relativeInstallPath()
1255 }
1256 return ""
1257}
1258
Jooyung Han344d5432019-08-23 11:17:39 +09001259func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001260 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001261}
1262
Colin Cross36242852017-06-23 15:06:31 -07001263func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001264 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001265 for _, generator := range c.generators {
1266 c.AddProperties(generator.GeneratorProps()...)
1267 }
Colin Crossca860ac2016-01-04 14:34:37 -08001268 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001269 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001270 }
1271 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001272 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001273 }
1274 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001275 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001276 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001277 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001278 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001279 }
Colin Cross16b23492016-01-06 14:41:07 -08001280 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001281 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001282 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001283 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001284 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001285 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001286 if c.fuzzer != nil {
1287 c.AddProperties(c.fuzzer.props()...)
1288 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001289 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001290 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001291 }
Justin Yun8effde42017-06-23 19:24:43 +09001292 if c.vndkdep != nil {
1293 c.AddProperties(c.vndkdep.props()...)
1294 }
Stephen Craneba090d12017-05-09 15:44:35 -07001295 if c.lto != nil {
1296 c.AddProperties(c.lto.props()...)
1297 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001298 if c.afdo != nil {
1299 c.AddProperties(c.afdo.props()...)
1300 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001301 if c.orderfile != nil {
1302 c.AddProperties(c.orderfile.props()...)
1303 }
Colin Crossca860ac2016-01-04 14:34:37 -08001304 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001305 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001306 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001307 // Allow test-only on libraries that are not cc_test_library
1308 if c.library != nil && !c.testLibrary() {
1309 c.AddProperties(&c.sourceProperties)
1310 }
Colin Crossc472d572015-03-17 15:06:21 -07001311
Colin Cross36242852017-06-23 15:06:31 -07001312 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001313 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001314 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001315
Colin Cross36242852017-06-23 15:06:31 -07001316 return c
Colin Crossc472d572015-03-17 15:06:21 -07001317}
1318
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001319// UseVndk() returns true if this module is built against VNDK.
1320// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001321func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001322 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001323}
1324
Colin Crossc511bc52020-04-07 16:50:32 +00001325func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001326 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001327 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001328}
1329
1330func (c *Module) UseSdk() bool {
1331 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001332 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001333 }
1334 return false
1335}
1336
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001337func (c *Module) isCoverageVariant() bool {
1338 return c.coverage.Properties.IsCoverageVariant
1339}
1340
Colin Cross95f1ca02020-10-29 20:47:22 -07001341func (c *Module) IsNdk(config android.Config) bool {
1342 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001343}
1344
Colin Cross127bb8b2020-12-16 16:46:01 -08001345func (c *Module) IsLlndk() bool {
1346 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001347}
1348
Colin Cross127bb8b2020-12-16 16:46:01 -08001349func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001350 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001351}
1352
Colin Cross1f3f1302021-04-26 18:37:44 -07001353func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001354 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001355 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001356}
1357
Colin Cross5271fea2021-04-27 13:06:04 -07001358func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1359 lib := moduleLibraryInterface(m)
1360 return lib != nil && (lib.hasVendorPublicLibrary())
1361}
1362
1363// IsVendorPublicLibrary returns true for vendor public libraries.
1364func (c *Module) IsVendorPublicLibrary() bool {
1365 return c.VendorProperties.IsVendorPublicLibrary
1366}
1367
Ivan Lozanof1868af2022-04-12 13:08:36 -04001368func (c *Module) IsVndkPrebuiltLibrary() bool {
1369 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1370 return true
1371 }
1372 return false
1373}
1374
1375func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1376 return c.Properties.SdkAndPlatformVariantVisibleToMake
1377}
1378
Ivan Lozanod7586b62021-04-01 09:49:36 -04001379func (c *Module) HasLlndkStubs() bool {
1380 lib := moduleLibraryInterface(c)
1381 return lib != nil && lib.hasLLNDKStubs()
1382}
1383
1384func (c *Module) StubsVersion() string {
1385 if lib, ok := c.linker.(versionedInterface); ok {
1386 return lib.stubsVersion()
1387 }
1388 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1389}
1390
Colin Cross127bb8b2020-12-16 16:46:01 -08001391// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1392// and does not set llndk.vendor_available: false.
1393func (c *Module) isImplementationForLLNDKPublic() bool {
1394 library, _ := c.library.(*libraryDecorator)
1395 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001396 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001397}
1398
Justin Yunfd9e8042020-12-23 18:23:14 +09001399// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001400func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001401 // Check if VNDK-core-private or VNDK-SP-private
1402 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001403 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001404 }
1405
1406 // Check if LLNDK-private
1407 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001408 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001409 }
1410
1411 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001412}
1413
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001414// IsVndk() returns true if this module has a vndk variant.
1415// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1416// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001417func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001418 if vndkdep := c.vndkdep; vndkdep != nil {
1419 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001420 }
1421 return false
1422}
1423
Colin Cross3513fb12024-01-24 14:44:47 -08001424func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001425 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001426 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001427 }
1428 return false
1429}
1430
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001431func (c *Module) isOrderfileCompile() bool {
1432 if orderfile := c.orderfile; orderfile != nil {
1433 return orderfile.Properties.OrderfileLoad
1434 }
1435 return false
1436}
1437
Yi Kongc702ebd2022-08-19 16:02:45 +08001438func (c *Module) isCfi() bool {
1439 if sanitize := c.sanitize; sanitize != nil {
Yi Kongddffe722023-07-18 16:40:36 +09001440 return Bool(sanitize.Properties.SanitizeMutated.Cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001441 }
1442 return false
1443}
1444
Yi Konged79fa32023-06-04 17:15:42 +09001445func (c *Module) isFuzzer() bool {
1446 if sanitize := c.sanitize; sanitize != nil {
1447 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1448 }
1449 return false
1450}
1451
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001452func (c *Module) isNDKStubLibrary() bool {
1453 if _, ok := c.compiler.(*stubDecorator); ok {
1454 return true
1455 }
1456 return false
1457}
1458
Ivan Lozanod7586b62021-04-01 09:49:36 -04001459func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001460 if vndkdep := c.vndkdep; vndkdep != nil {
1461 return vndkdep.isVndkSp()
1462 }
1463 return false
1464}
1465
Ivan Lozanof9e21722020-12-02 09:00:51 -05001466func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001467 if vndkdep := c.vndkdep; vndkdep != nil {
1468 return vndkdep.isVndkExt()
1469 }
1470 return false
1471}
1472
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001473func (c *Module) SubName() string {
1474 return c.Properties.SubName
1475}
1476
Logan Chienf3511742017-10-31 18:04:35 +08001477func (c *Module) getVndkExtendsModuleName() string {
1478 if vndkdep := c.vndkdep; vndkdep != nil {
1479 return vndkdep.getVndkExtendsModuleName()
1480 }
1481 return ""
1482}
1483
Jiyong Park25fc6a92018-11-18 18:02:45 +09001484func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001485 if lib := c.library; lib != nil {
1486 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001487 }
1488 return false
1489}
1490
1491func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001492 if lib := c.library; lib != nil {
1493 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001494 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001495 return false
1496}
1497
Alan Stokes73feba32022-11-14 12:21:24 +00001498func (c *Module) IsStubsImplementationRequired() bool {
1499 if lib := c.library; lib != nil {
1500 return lib.isStubsImplementationRequired()
1501 }
1502 return false
1503}
1504
Colin Cross0477b422020-10-13 18:43:54 -07001505// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1506// the implementation. If it is an implementation library it returns its own name.
1507func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1508 name := ctx.OtherModuleName(c)
1509 if versioned, ok := c.linker.(versionedInterface); ok {
1510 name = versioned.implementationModuleName(name)
1511 }
1512 return name
1513}
1514
Martin Stjernholm2856c662020-12-02 15:03:42 +00001515// Similar to ImplementationModuleName, but uses the Make variant of the module
1516// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1517// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1518// under the premise that the prebuilt module overrides its source counterpart
1519// if it is exposed to Make).
1520func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1521 name := c.BaseModuleName()
1522 if versioned, ok := c.linker.(versionedInterface); ok {
1523 name = versioned.implementationModuleName(name)
1524 }
1525 return name
1526}
1527
Jiyong Park7d55b612021-06-11 17:22:09 +09001528func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001529 return Bool(c.Properties.Bootstrap)
1530}
1531
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001532func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001533 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1534 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1535 return false
1536 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001537 return c.linker != nil && c.linker.nativeCoverage()
1538}
1539
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001540func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001541 if p, ok := c.linker.(SnapshotInterface); ok {
1542 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001543 }
1544 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001545}
1546
Jiyong Parkf1194352019-02-25 11:05:47 +09001547func isBionic(name string) bool {
1548 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001549 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001550 return true
1551 }
1552 return false
1553}
1554
Martin Stjernholm279de572019-09-10 23:18:20 +01001555func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001556 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001557 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001558 }
1559 return isBionic(name)
1560}
1561
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001562func (c *Module) XrefCcFiles() android.Paths {
1563 return c.kytheFiles
1564}
1565
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001566func (c *Module) isCfiAssemblySupportEnabled() bool {
1567 return c.sanitize != nil &&
1568 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1569}
1570
Inseob Kim800d1142021-06-14 12:03:51 +09001571func (c *Module) InstallInRoot() bool {
1572 return c.installer != nil && c.installer.installInRoot()
1573}
1574
Colin Crossca860ac2016-01-04 14:34:37 -08001575type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001576 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001577 moduleContextImpl
1578}
1579
Colin Cross37047f12016-12-13 17:06:13 -08001580type depsContext struct {
1581 android.BottomUpMutatorContext
1582 moduleContextImpl
1583}
1584
Colin Crossca860ac2016-01-04 14:34:37 -08001585type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001586 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001587 moduleContextImpl
1588}
1589
1590type moduleContextImpl struct {
1591 mod *Module
1592 ctx BaseModuleContext
1593}
1594
Colin Crossb98c8b02016-07-29 13:44:28 -07001595func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001596 return ctx.mod.toolchain(ctx.ctx)
1597}
1598
1599func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001600 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001601}
1602
1603func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001604 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001605}
1606
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001607func (ctx *moduleContextImpl) testBinary() bool {
1608 return ctx.mod.testBinary()
1609}
1610
Yi Kong56fc1b62022-09-06 16:24:00 +08001611func (ctx *moduleContextImpl) testLibrary() bool {
1612 return ctx.mod.testLibrary()
1613}
1614
Jiyong Park1d1119f2019-07-29 21:27:18 +09001615func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001616 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001617}
1618
Inseob Kim7f283f42020-06-01 21:53:49 +09001619func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001620 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001621}
1622
Inseob Kim1042d292020-06-01 23:23:05 +09001623func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001624 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001625}
1626
Yi Kong5786f5c2024-05-28 02:22:34 +09001627func (ctx *moduleContextImpl) optimizeForSize() bool {
1628 return ctx.mod.OptimizeForSize()
1629}
1630
Jooyung Hanccce2f22020-03-07 03:45:53 +09001631func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001632 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001633}
1634
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001635func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001636 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001637}
1638
1639func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001640 if ctx.ctx.Device() {
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001641 config := ctx.ctx.Config()
1642 if !config.IsVndkDeprecated() && ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001643 vndkVer := ctx.mod.VndkVersion()
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001644 if inList(vndkVer, config.PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001645 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001646 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001647 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001648 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001649 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001650 }
1651 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001652}
1653
Jiyong Parkb35a8192020-08-10 15:59:36 +09001654func (ctx *moduleContextImpl) minSdkVersion() string {
1655 ver := ctx.mod.MinSdkVersion()
1656 if ver == "apex_inherit" && !ctx.isForPlatform() {
1657 ver = ctx.apexSdkVersion().String()
1658 }
1659 if ver == "apex_inherit" || ver == "" {
1660 ver = ctx.sdkVersion()
1661 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001662
1663 if ctx.ctx.Device() {
1664 config := ctx.ctx.Config()
1665 if config.IsVndkDeprecated() && ctx.inVendor() {
1666 // If building for vendor with final API, then use the latest _stable_ API as "current".
1667 if config.VendorApiLevelFrozen() && (ver == "" || ver == "current") {
1668 ver = config.PlatformSdkVersion().String()
1669 }
1670 }
1671 }
1672
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001673 // For crt objects, the meaning of min_sdk_version is very different from other types of
1674 // module. For them, min_sdk_version defines the oldest version that the build system will
1675 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1676 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1677 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001678 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1679 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1680 // support such an old version. The version is set to the later version in case when the
1681 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1682 // it's for an APEX.
1683 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1684 if ctx.isForPlatform() {
1685 ver = strconv.Itoa(android.FutureApiLevelInt)
1686 } else { // for apex
1687 ver = ctx.apexSdkVersion().String()
1688 if ver == "" { // in case when min_sdk_version was not set by the APEX
1689 ver = ctx.sdkVersion()
1690 }
1691 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001692 }
1693
Jiyong Parkb35a8192020-08-10 15:59:36 +09001694 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1695 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1696 minSdkVersionInt, err2 := strconv.Atoi(ver)
1697 if err == nil && err2 == nil {
1698 if sdkVersionInt < minSdkVersionInt {
1699 return strconv.Itoa(sdkVersionInt)
1700 }
1701 }
1702 return ver
1703}
1704
1705func (ctx *moduleContextImpl) isSdkVariant() bool {
1706 return ctx.mod.IsSdkVariant()
1707}
1708
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001709func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001710 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001711}
Justin Yun8effde42017-06-23 19:24:43 +09001712
Kiyoung Kimaa394802024-01-08 12:55:45 +09001713func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1714 return ctx.mod.InVendorOrProduct()
1715}
1716
Colin Cross95f1ca02020-10-29 20:47:22 -07001717func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1718 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001719}
1720
Colin Cross127bb8b2020-12-16 16:46:01 -08001721func (ctx *moduleContextImpl) IsLlndk() bool {
1722 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001723}
1724
Colin Cross127bb8b2020-12-16 16:46:01 -08001725func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1726 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001727}
1728
Colin Cross127bb8b2020-12-16 16:46:01 -08001729func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1730 return ctx.mod.isImplementationForLLNDKPublic()
1731}
1732
1733func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1734 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001735}
1736
Logan Chienf3511742017-10-31 18:04:35 +08001737func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001738 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001739}
1740
Colin Cross3513fb12024-01-24 14:44:47 -08001741func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1742 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001743}
1744
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001745func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1746 return ctx.mod.isOrderfileCompile()
1747}
1748
Yi Kongc702ebd2022-08-19 16:02:45 +08001749func (ctx *moduleContextImpl) isCfi() bool {
1750 return ctx.mod.isCfi()
1751}
1752
Yi Konged79fa32023-06-04 17:15:42 +09001753func (ctx *moduleContextImpl) isFuzzer() bool {
1754 return ctx.mod.isFuzzer()
1755}
1756
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001757func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1758 return ctx.mod.isNDKStubLibrary()
1759}
1760
Justin Yun8effde42017-06-23 19:24:43 +09001761func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001762 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001763}
1764
Ivan Lozanof9e21722020-12-02 09:00:51 -05001765func (ctx *moduleContextImpl) IsVndkExt() bool {
1766 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001767}
1768
Colin Cross5271fea2021-04-27 13:06:04 -07001769func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1770 return ctx.mod.IsVendorPublicLibrary()
1771}
1772
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001773func (ctx *moduleContextImpl) selectedStl() string {
1774 if stl := ctx.mod.stl; stl != nil {
1775 return stl.Properties.SelectedStl
1776 }
1777 return ""
1778}
1779
Ivan Lozanobd721262018-11-27 14:33:03 -08001780func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1781 return ctx.mod.linker.useClangLld(actx)
1782}
1783
Colin Crossce75d2c2016-10-06 16:12:58 -07001784func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001785 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001786}
1787
Logan Chienf3511742017-10-31 18:04:35 +08001788func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1789 return ctx.mod.getVndkExtendsModuleName()
1790}
1791
Logan Chiene274fc92019-12-03 11:18:32 -08001792func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001793 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1794 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001795}
1796
Colin Crosse07f2312020-08-13 11:24:56 -07001797func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001798 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1799 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001800}
1801
Dan Albertc8060532020-07-22 22:32:17 -07001802func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001803 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001804}
1805
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001806func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001807 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001808}
1809
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001810func (ctx *moduleContextImpl) nativeCoverage() bool {
1811 return ctx.mod.nativeCoverage()
1812}
1813
Colin Cross56a83212020-09-15 18:30:11 -07001814func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1815 return ctx.mod.DirectlyInAnyApex()
1816}
1817
Colin Cross95b07f22020-12-16 11:06:50 -08001818func (ctx *moduleContextImpl) isPreventInstall() bool {
1819 return ctx.mod.Properties.PreventInstall
1820}
1821
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001822func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1823 shared := &ctx.mod.sharedFlags
1824 if shared.flagsMap == nil {
1825 shared.numSharedFlags = 0
1826 shared.flagsMap = make(map[string]string)
1827 }
1828 return shared
1829}
1830
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001831func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1832 return ctx.mod.isCfiAssemblySupportEnabled()
1833}
1834
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001835func (ctx *moduleContextImpl) notInPlatform() bool {
1836 return ctx.mod.NotInPlatform()
1837}
1838
Colin Cross635c3b02016-05-18 15:37:25 -07001839func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001840 return &Module{
1841 hod: hod,
1842 multilib: multilib,
1843 }
1844}
1845
Colin Cross635c3b02016-05-18 15:37:25 -07001846func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001847 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001848 module.features = []feature{
1849 &tidyFeature{},
1850 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001851 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001852 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001853 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001854 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001855 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001856 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001857 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001858 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001859 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001860 return module
1861}
1862
Colin Crossce75d2c2016-10-06 16:12:58 -07001863func (c *Module) Prebuilt() *android.Prebuilt {
1864 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1865 return p.prebuilt()
1866 }
1867 return nil
1868}
1869
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001870func (c *Module) IsPrebuilt() bool {
1871 return c.Prebuilt() != nil
1872}
1873
Colin Crossce75d2c2016-10-06 16:12:58 -07001874func (c *Module) Name() string {
1875 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001876 if p, ok := c.linker.(interface {
1877 Name(string) string
1878 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001879 name = p.Name(name)
1880 }
1881 return name
1882}
1883
Alex Light3d673592019-01-18 14:37:31 -08001884func (c *Module) Symlinks() []string {
1885 if p, ok := c.installer.(interface {
1886 symlinkList() []string
1887 }); ok {
1888 return p.symlinkList()
1889 }
1890 return nil
1891}
1892
Roland Levillainf89cd092019-07-29 16:22:59 +01001893func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1894 test, ok := c.linker.(testPerSrc)
1895 return ok && test.isAllTestsVariation()
1896}
1897
Chris Parsons216e10a2020-07-09 17:12:52 -04001898func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001899 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001900 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001901 }); ok {
1902 return p.dataPaths()
1903 }
1904 return nil
1905}
1906
Ivan Lozanof1868af2022-04-12 13:08:36 -04001907func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001908 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1909 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001910 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001911 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001912 if c.ProductSpecific() {
1913 // If the module is product specific with 'product_specific: true',
1914 // do not add a name suffix because it is a base module.
1915 return ""
1916 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001917 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001918 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001919 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001920 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001921 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001922 // add version suffix only if the module is using different vndk version than the
1923 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001924 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001925 }
1926 return nameSuffix
1927}
1928
Ivan Lozanof1868af2022-04-12 13:08:36 -04001929func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1930 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001931
1932 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001933 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001934 }
1935
Colin Cross127bb8b2020-12-16 16:46:01 -08001936 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001937 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001938 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1939 // added for product variant only when we have vendor and product variants with core
1940 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001941 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001942 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001943 subName += vendorPublicLibrarySuffix
1944 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001945 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1946 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001947 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001948 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001949 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001950 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001951 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001952 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001953 subName += RecoverySuffix
1954 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1955 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001956 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001957 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001958 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001959 } else if c.IsStubs() && c.IsSdkVariant() {
1960 // Public API surface (NDK)
1961 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1962 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001963 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001964
1965 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001966}
1967
Sam Delmerico75dbca22023-04-20 13:13:25 +00001968func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1969 ctx := &moduleContext{
1970 ModuleContext: actx,
1971 moduleContextImpl: moduleContextImpl{
1972 mod: c,
1973 },
1974 }
1975 ctx.ctx = ctx
1976 return ctx
1977}
1978
Spandan Das20fce2d2023-04-12 17:21:39 +00001979// TODO (b/277651159): Remove this allowlist
1980var (
1981 skipStubLibraryMultipleApexViolation = map[string]bool{
1982 "libclang_rt.asan": true,
1983 "libclang_rt.hwasan": true,
1984 // runtime apex
1985 "libc": true,
1986 "libc_hwasan": true,
1987 "libdl_android": true,
1988 "libm": true,
1989 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001990 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001991 // art apex
1992 "libandroidio": true,
1993 "libdexfile": true,
1994 "libnativebridge": true,
1995 "libnativehelper": true,
1996 "libnativeloader": true,
1997 "libsigchain": true,
1998 }
1999)
2000
2001// Returns true if a stub library could be installed in multiple apexes
2002func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
2003 // If this is not an apex variant, no check necessary
2004 if !c.InAnyApex() {
2005 return false
2006 }
2007 // If this is not a stub library, no check necessary
2008 if !c.HasStubsVariants() {
2009 return false
2010 }
2011 // Skip the allowlist
2012 // Use BaseModuleName so that this matches prebuilts.
2013 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
2014 return false
2015 }
2016
2017 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
2018 // Stub libraries should not have more than one apex_available
2019 if len(aaWithoutTestApexes) > 1 {
2020 return true
2021 }
2022 // Stub libraries should not use the wildcard
2023 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
2024 return true
2025 }
2026 // Default: no violation
2027 return false
2028}
2029
Chris Parsons8d6e4332021-02-22 16:13:50 -05002030func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07002031 ctx := moduleContextFromAndroidModuleContext(actx, c)
2032
Inseob Kim37e0bb02024-04-29 15:54:44 +09002033 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
2034 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
2035 Logtags: c.logtagsPaths,
2036 })
2037
Ronald Braunstein6a08d492024-04-15 12:55:30 -07002038 // If Test_only is set on a module in bp file, respect the setting, otherwise
2039 // see if is a known test module type.
2040 testOnly := c.testModule || c.testLibrary()
2041 if c.sourceProperties.Test_only != nil {
2042 testOnly = Bool(c.sourceProperties.Test_only)
2043 }
2044 // Keep before any early returns.
2045 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
2046 TestOnly: testOnly,
2047 TopLevelTarget: c.testModule,
2048 })
2049
Chris Parsons8d6e4332021-02-22 16:13:50 -05002050 // Handle the case of a test module split by `test_per_src` mutator.
2051 //
2052 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
2053 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
2054 // module and return early, as this module does not produce an output file per se.
2055 if c.IsTestPerSrcAllTestsVariation() {
2056 c.outputFile = android.OptionalPath{}
2057 return
2058 }
2059
Ivan Lozanof1868af2022-04-12 13:08:36 -04002060 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08002061 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05002062 if !apexInfo.IsForPlatform() {
2063 c.hideApexVariantFromMake = true
2064 }
2065
Chris Parsonseefc9e62021-04-02 17:36:47 -04002066 c.makeLinkType = GetMakeLinkType(actx, c)
2067
Colin Crossf18e1102017-11-16 14:33:08 -08002068 deps := c.depsToPaths(ctx)
2069 if ctx.Failed() {
2070 return
2071 }
2072
Joe Onorato37f900c2023-07-18 16:58:16 -07002073 for _, generator := range c.generators {
2074 gen := generator.GeneratorSources(ctx)
2075 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
2076 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
2077 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
2078 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
2079 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
2080 if len(deps.Objs.objFiles) == 0 {
2081 // If we are reusuing object files (which happens when we're a shared library and we're
2082 // reusing our static variant's object files), then skip adding the actual source files,
2083 // because we already have the object for it.
2084 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
2085 }
2086 }
2087
2088 if ctx.Failed() {
2089 return
2090 }
2091
Spandan Das20fce2d2023-04-12 17:21:39 +00002092 if c.stubLibraryMultipleApexViolation(actx) {
2093 actx.PropertyErrorf("apex_available",
2094 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
2095 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002096 if c.Properties.Clang != nil && *c.Properties.Clang == false {
2097 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00002098 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
2099 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002100 }
2101
Colin Crossca860ac2016-01-04 14:34:37 -08002102 flags := Flags{
2103 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002104 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002105 }
Joe Onorato37f900c2023-07-18 16:58:16 -07002106 for _, generator := range c.generators {
2107 flags = generator.GeneratorFlags(ctx, flags, deps)
2108 }
Colin Crossca860ac2016-01-04 14:34:37 -08002109 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002110 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002111 }
2112 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002113 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002114 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002115 if c.stl != nil {
2116 flags = c.stl.flags(ctx, flags)
2117 }
Colin Cross16b23492016-01-06 14:41:07 -08002118 if c.sanitize != nil {
2119 flags = c.sanitize.flags(ctx, flags)
2120 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002121 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002122 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002123 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002124 if c.fuzzer != nil {
2125 flags = c.fuzzer.flags(ctx, flags)
2126 }
Stephen Craneba090d12017-05-09 15:44:35 -07002127 if c.lto != nil {
2128 flags = c.lto.flags(ctx, flags)
2129 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002130 if c.afdo != nil {
2131 flags = c.afdo.flags(ctx, flags)
2132 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002133 if c.orderfile != nil {
2134 flags = c.orderfile.flags(ctx, flags)
2135 }
Colin Crossca860ac2016-01-04 14:34:37 -08002136 for _, feature := range c.features {
2137 flags = feature.flags(ctx, flags)
2138 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002139 if ctx.Failed() {
2140 return
2141 }
2142
Colin Cross4af21ed2019-11-04 09:37:55 -08002143 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2144 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2145 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002146
Colin Cross4af21ed2019-11-04 09:37:55 -08002147 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002148
2149 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002150 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002151 }
2152 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002153 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002154 }
2155
Colin Cross3e5e7782022-06-17 22:17:05 +00002156 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2157
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002158 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002159 // We need access to all the flags seen by a source file.
2160 if c.sabi != nil {
2161 flags = c.sabi.flags(ctx, flags)
2162 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002163
Colin Cross4af21ed2019-11-04 09:37:55 -08002164 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002165
Joe Onorato37f900c2023-07-18 16:58:16 -07002166 for _, generator := range c.generators {
2167 generator.GeneratorBuildActions(ctx, flags, deps)
2168 }
2169
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002170 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002171 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002172 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002173 if ctx.Failed() {
2174 return
2175 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002176 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002177 c.objFiles = objs.objFiles
2178 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002179 }
2180
Colin Crossca860ac2016-01-04 14:34:37 -08002181 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002182 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002183 if ctx.Failed() {
2184 return
2185 }
Colin Cross635c3b02016-05-18 15:37:25 -07002186 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002187
Chris Parsons94a0bba2021-06-04 15:03:47 -04002188 c.maybeUnhideFromMake()
Colin Crossce75d2c2016-10-06 16:12:58 -07002189 }
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002190 if c.testModule {
Colin Cross40213022023-12-13 15:19:49 -08002191 android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{})
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002192 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002193
Colin Cross40213022023-12-13 15:19:49 -08002194 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002195
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002196 if Bool(c.Properties.Cmake_snapshot_supported) {
2197 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2198 }
2199
Chris Parsons94a0bba2021-06-04 15:03:47 -04002200 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002201
2202 if c.linker != nil {
2203 moduleInfoJSON := ctx.ModuleInfoJSON()
2204 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2205 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2206 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2207 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2208 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2209
2210 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2211 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2212 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2213 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2214
2215 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2216 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2217 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2218 moduleInfoJSON.SubName += ".cfi"
2219 }
2220 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2221 moduleInfoJSON.SubName += ".hwasan"
2222 }
2223 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2224 moduleInfoJSON.SubName += ".scs"
2225 }
2226 }
2227 moduleInfoJSON.SubName += c.Properties.SubName
2228
2229 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2230 moduleInfoJSON.Uninstallable = true
2231 }
2232
2233 }
Chris Parsons94a0bba2021-06-04 15:03:47 -04002234}
2235
2236func (c *Module) maybeUnhideFromMake() {
2237 // If a lib is directly included in any of the APEXes or is not available to the
2238 // platform (which is often the case when the stub is provided as a prebuilt),
2239 // unhide the stubs variant having the latest version gets visible to make. In
2240 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2241 // force anything in the make world to link against the stubs library. (unless it
2242 // is explicitly referenced via .bootstrap suffix or the module is marked with
2243 // 'bootstrap: true').
2244 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002245 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002246 c.IsStubs() && !c.InVendorRamdisk() {
2247 c.Properties.HideFromMake = false // unhide
2248 // Note: this is still non-installable
2249 }
2250}
2251
Colin Cross8ff10582023-12-07 13:10:56 -08002252// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2253// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002254func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002255 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002256 // If the module has been specifically configure to not be installed then
2257 // hide from make as otherwise it will break when running inside make
2258 // as the output path to install will not be specified. Not all uninstallable
2259 // modules can be hidden from make as some are needed for resolving make side
2260 // dependencies.
2261 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002262 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002263 c.SkipInstall()
2264 }
2265
2266 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2267 // to allow using the outputs in a genrule.
2268 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002269 c.installer.install(ctx, c.outputFile.Path())
2270 if ctx.Failed() {
2271 return
Colin Crossca860ac2016-01-04 14:34:37 -08002272 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002273 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002274}
2275
Colin Cross0ea8ba82019-06-06 14:33:29 -07002276func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002277 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002278 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002279 }
Colin Crossca860ac2016-01-04 14:34:37 -08002280 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002281}
2282
Colin Crossca860ac2016-01-04 14:34:37 -08002283func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002284 for _, generator := range c.generators {
2285 generator.GeneratorInit(ctx)
2286 }
Colin Crossca860ac2016-01-04 14:34:37 -08002287 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002288 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002289 }
Colin Crossca860ac2016-01-04 14:34:37 -08002290 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002291 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002292 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002293 if c.stl != nil {
2294 c.stl.begin(ctx)
2295 }
Colin Cross16b23492016-01-06 14:41:07 -08002296 if c.sanitize != nil {
2297 c.sanitize.begin(ctx)
2298 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002299 if c.coverage != nil {
2300 c.coverage.begin(ctx)
2301 }
Yi Kong9723e332023-12-04 14:52:53 +09002302 if c.afdo != nil {
2303 c.afdo.begin(ctx)
2304 }
Stephen Craneba090d12017-05-09 15:44:35 -07002305 if c.lto != nil {
2306 c.lto.begin(ctx)
2307 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002308 if c.orderfile != nil {
2309 c.orderfile.begin(ctx)
2310 }
Dan Albert92fe7402020-07-15 13:33:30 -07002311 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002312 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002313 if err != nil {
2314 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002315 c.Properties.Sdk_version = nil
2316 } else {
2317 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002318 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002319 }
Colin Crossca860ac2016-01-04 14:34:37 -08002320}
2321
Colin Cross37047f12016-12-13 17:06:13 -08002322func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002323 deps := Deps{}
2324
Joe Onorato37f900c2023-07-18 16:58:16 -07002325 for _, generator := range c.generators {
2326 deps = generator.GeneratorDeps(ctx, deps)
2327 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002328 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002329 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002330 }
2331 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002332 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002333 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002334 if c.stl != nil {
2335 deps = c.stl.deps(ctx, deps)
2336 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002337 if c.coverage != nil {
2338 deps = c.coverage.deps(ctx, deps)
2339 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002340
Colin Crossb6715442017-10-24 11:13:31 -07002341 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2342 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
Ivan Lozano0a468a42024-05-13 21:03:34 -04002343 deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
Colin Crossb6715442017-10-24 11:13:31 -07002344 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2345 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2346 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2347 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002348 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002349 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002350
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002351 for _, lib := range deps.ReexportSharedLibHeaders {
2352 if !inList(lib, deps.SharedLibs) {
2353 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2354 }
2355 }
2356
2357 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002358 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2359 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 -07002360 }
2361 }
2362
Colin Cross5950f382016-12-13 12:50:57 -08002363 for _, lib := range deps.ReexportHeaderLibHeaders {
2364 if !inList(lib, deps.HeaderLibs) {
2365 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2366 }
2367 }
2368
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002369 for _, gen := range deps.ReexportGeneratedHeaders {
2370 if !inList(gen, deps.GeneratedHeaders) {
2371 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2372 }
2373 }
2374
Colin Crossc99deeb2016-04-11 15:06:20 -07002375 return deps
2376}
2377
Dan Albert7e9d2952016-08-04 13:02:36 -07002378func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002379 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002380 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002381 moduleContextImpl: moduleContextImpl{
2382 mod: c,
2383 },
2384 }
2385 ctx.ctx = ctx
2386
Colin Crossca860ac2016-01-04 14:34:37 -08002387 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002388}
2389
Jiyong Park7ed9de32018-10-15 22:25:07 +09002390// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002391func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002392 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2393 version := name[sharp+1:]
2394 libname := name[:sharp]
2395 return libname, version
2396 }
2397 return name, ""
2398}
2399
Dan Albert92fe7402020-07-15 13:33:30 -07002400func GetCrtVariations(ctx android.BottomUpMutatorContext,
2401 m LinkableInterface) []blueprint.Variation {
2402 if ctx.Os() != android.Android {
2403 return nil
2404 }
2405 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002406 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2407 minSdkVersion := m.MinSdkVersion()
2408 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2409 minSdkVersion = m.SdkVersion()
2410 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002411 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2412 if err != nil {
2413 ctx.PropertyErrorf("min_sdk_version", err.Error())
2414 }
Colin Cross363ec762023-01-13 13:45:14 -08002415
2416 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002417 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002418 if apiLevel.LessThan(minApiForArch) {
2419 apiLevel = minApiForArch
2420 }
2421
Dan Albert92fe7402020-07-15 13:33:30 -07002422 return []blueprint.Variation{
2423 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002424 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002425 }
2426 }
2427 return []blueprint.Variation{
2428 {Mutator: "sdk", Variation: ""},
2429 }
2430}
2431
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002432func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2433 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002434
2435 variations = append([]blueprint.Variation(nil), variations...)
2436
Liz Kammer23942242022-04-08 15:41:00 -04002437 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002438 // Version is explicitly specified. i.e. libFoo#30
2439 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002440 if tag, ok := depTag.(libraryDependencyTag); ok {
2441 tag.explicitlyVersioned = true
2442 } else {
2443 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2444 }
Colin Crosse7257d22020-09-24 09:56:18 -07002445 }
Colin Crosse7257d22020-09-24 09:56:18 -07002446
Colin Cross0de8a1e2020-09-18 14:15:30 -07002447 if far {
2448 ctx.AddFarVariationDependencies(variations, depTag, name)
2449 } else {
2450 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002451 }
2452}
2453
Kiyoung Kim487689e2022-07-26 09:48:22 +09002454func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2455 apiImportInfo := multitree.ApiImportInfo{}
2456
2457 if c.Device() {
2458 var apiImportModule []blueprint.Module
2459 if actx.OtherModuleExists("api_imports") {
2460 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2461 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
Colin Cross313aa542023-12-13 13:47:44 -08002462 apiInfo, _ := android.OtherModuleProvider(actx, apiImportModule[0], multitree.ApiImportsProvider)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002463 apiImportInfo = apiInfo
Colin Cross40213022023-12-13 15:19:49 -08002464 android.SetProvider(actx, multitree.ApiImportsProvider, apiInfo)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002465 }
2466 }
2467 }
2468
2469 return apiImportInfo
2470}
2471
Kiyoung Kim487689e2022-07-26 09:48:22 +09002472func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2473 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002474 return snapshot
2475 }
2476
2477 return lib
2478}
2479
Kiyoung Kim37693d02024-04-04 09:56:15 +09002480// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002481// of names:
2482//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002483// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002484//
2485// For each of these, it adds the name of the ndk_library module to the list of
2486// variant libs.
2487//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002488// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002489//
2490// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002491//
2492// The caller can then know to add the variantLibs dependencies differently from the
2493// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002494func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002495 variantLibs = []string{}
2496
2497 nonvariantLibs = []string{}
2498 for _, entry := range list {
2499 // strip #version suffix out
2500 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002501 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002502 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002503 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002504 nonvariantLibs = append(nonvariantLibs, entry)
2505 }
2506 }
2507 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002508
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002509}
2510
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002511func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2512 nonVariantLibs := []string{}
2513 variantLibs := []string{}
2514
2515 for _, lib := range libs {
2516 replaceLibName := GetReplaceModuleName(lib, replaceList)
2517 if replaceLibName == lib {
2518 // Do not handle any libs which are not in API imports
2519 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2520 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2521 variantLibs = append(variantLibs, replaceLibName)
2522 } else {
2523 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2524 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002525 }
2526
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002527 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002528}
2529
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002530func (c *Module) shouldUseApiSurface() bool {
2531 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2532 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2533 // LLNDK Variant
2534 return true
2535 }
2536
2537 if c.Properties.IsSdkVariant {
2538 // NDK Variant
2539 return true
2540 }
2541
2542 if c.isImportedApiLibrary() {
2543 // API Library should depend on API headers
2544 return true
2545 }
2546 }
2547
2548 return false
2549}
2550
Colin Cross1e676be2016-10-12 14:38:15 -07002551func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002552 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002553 return
2554 }
2555
Colin Cross37047f12016-12-13 17:06:13 -08002556 ctx := &depsContext{
2557 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002558 moduleContextImpl: moduleContextImpl{
2559 mod: c,
2560 },
2561 }
2562 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002563
Colin Crossc99deeb2016-04-11 15:06:20 -07002564 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002565 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002566
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002567 apiNdkLibs := []string{}
2568 apiLateNdkLibs := []string{}
2569
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002570 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002571 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2572 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2573 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2574 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2575 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002576 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002577
Yo Chiang219968c2020-09-22 18:45:04 +08002578 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2579
Dan Albert914449f2016-06-17 16:45:24 -07002580 variantNdkLibs := []string{}
2581 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002582 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002583 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2584 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2585 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002586 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002587
Colin Cross32ec36c2016-12-15 07:39:51 -08002588 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002589 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002590 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002591 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002592 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002593
Kiyoung Kim51279d32022-08-24 14:10:46 +09002594 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002595 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002596 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2597 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002598
Spandan Das73bcafc2022-08-18 23:26:00 +00002599 if c.isNDKStubLibrary() {
2600 // ndk_headers do not have any variations
2601 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002602 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002603 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002604 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002605 } else {
2606 actx.AddVariationDependencies(nil, depTag, lib)
2607 }
2608 }
2609
Dan Albertf1d14c72020-07-30 14:32:55 -07002610 if c.isNDKStubLibrary() {
2611 // NDK stubs depend on their implementation because the ABI dumps are
2612 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002613
Spandan Das8b08aea2023-03-14 19:29:34 +00002614 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2615 c.ImageVariation(),
2616 blueprint.Variation{Mutator: "link", Variation: "shared"},
2617 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002618 }
2619
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002620 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2621 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2622 c.Target().NativeBridge == android.NativeBridgeDisabled {
2623 actx.AddVariationDependencies(
2624 []blueprint.Variation{{Mutator: "image", Variation: VendorVariation}},
2625 llndkHeaderLibTag,
2626 deps.LlndkHeaderLibs...)
2627 }
2628
Jiyong Park5d1598f2019-02-25 22:14:17 +09002629 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002630 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002631
Jiyong Park5d1598f2019-02-25 22:14:17 +09002632 actx.AddVariationDependencies([]blueprint.Variation{
2633 {Mutator: "link", Variation: "static"},
2634 }, depTag, lib)
2635 }
2636
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002637 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002638 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002639 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002640 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002641 }
Jiyong Parke3867542020-12-03 17:28:25 +09002642 if inList(lib, deps.ExcludeLibsForApex) {
2643 depTag.excludeInApex = true
2644 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002645
Dan Willemsen59339a22018-07-22 21:18:45 -07002646 actx.AddVariationDependencies([]blueprint.Variation{
2647 {Mutator: "link", Variation: "static"},
2648 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002649 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002650
Ivan Lozano0a468a42024-05-13 21:03:34 -04002651 for _, lib := range deps.Rlibs {
2652 depTag := libraryDependencyTag{Kind: rlibLibraryDependency}
2653 actx.AddVariationDependencies([]blueprint.Variation{
2654 {Mutator: "link", Variation: ""},
2655 {Mutator: "rust_libraries", Variation: "rlib"},
2656 {Mutator: "rust_stdlinkage", Variation: "rlib-std"},
2657 }, depTag, lib)
2658 }
2659
Jooyung Han75568392020-03-20 04:29:24 +09002660 // staticUnwinderDep is treated as staticDep for Q apexes
2661 // so that native libraries/binaries are linked with static unwinder
2662 // because Q libc doesn't have unwinder APIs
2663 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002664 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002665 actx.AddVariationDependencies([]blueprint.Variation{
2666 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002667 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002668 }
2669
Jiyong Park7ed9de32018-10-15 22:25:07 +09002670 // shared lib names without the #version suffix
2671 var sharedLibNames []string
2672
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002673 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002674 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002675 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002676 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002677 }
Jiyong Parke3867542020-12-03 17:28:25 +09002678 if inList(lib, deps.ExcludeLibsForApex) {
2679 depTag.excludeInApex = true
2680 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002681 if inList(lib, deps.ExcludeLibsForNonApex) {
2682 depTag.excludeInNonApex = true
2683 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002684
Jiyong Park73c54ee2019-10-22 20:31:18 +09002685 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002686 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2687 name = apiLibraryName
2688 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002689 sharedLibNames = append(sharedLibNames, name)
2690
Colin Crosse7257d22020-09-24 09:56:18 -07002691 variations := []blueprint.Variation{
2692 {Mutator: "link", Variation: "shared"},
2693 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002694
2695 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2696 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2697 }
2698
2699 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2700 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2701 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002702 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002703
Colin Crossfe9acfe2021-06-14 16:13:03 -07002704 for _, lib := range deps.LateStaticLibs {
2705 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2706 actx.AddVariationDependencies([]blueprint.Variation{
2707 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002708 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002709 }
2710
Colin Cross3e5e7782022-06-17 22:17:05 +00002711 for _, lib := range deps.UnexportedStaticLibs {
2712 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2713 actx.AddVariationDependencies([]blueprint.Variation{
2714 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002715 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002716 }
2717
Jiyong Park7ed9de32018-10-15 22:25:07 +09002718 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002719 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002720 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2721 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2722 // linking against both the stubs lib and the non-stubs lib at the same time.
2723 continue
2724 }
Colin Cross6e511a92020-07-27 21:26:48 -07002725 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002726 variations := []blueprint.Variation{
2727 {Mutator: "link", Variation: "shared"},
2728 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002729 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002730 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002731
Dan Willemsen59339a22018-07-22 21:18:45 -07002732 actx.AddVariationDependencies([]blueprint.Variation{
2733 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002734 }, dataLibDepTag, deps.DataLibs...)
2735
Colin Crossc8caa062021-09-24 16:50:14 -07002736 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2737
Chris Parsons79d66a52020-06-05 17:26:16 -04002738 actx.AddVariationDependencies([]blueprint.Variation{
2739 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002740 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002741
Colin Cross68861832016-07-08 10:41:41 -07002742 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002743
2744 for _, gen := range deps.GeneratedHeaders {
2745 depTag := genHeaderDepTag
2746 if inList(gen, deps.ReexportGeneratedHeaders) {
2747 depTag = genHeaderExportDepTag
2748 }
2749 actx.AddDependency(c, depTag, gen)
2750 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002751
Dan Albert92fe7402020-07-15 13:33:30 -07002752 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002753 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002754 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002755 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002756 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002757 }
Colin Crossc465efd2021-06-11 18:00:04 -07002758 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002759 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002760 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002761 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002762 if deps.DynamicLinker != "" {
2763 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002764 }
Dan Albert914449f2016-06-17 16:45:24 -07002765
2766 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002767
2768 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002769 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002770 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002771 {Mutator: "link", Variation: "shared"},
2772 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002773 actx.AddVariationDependencies([]blueprint.Variation{
2774 {Mutator: "version", Variation: version},
2775 {Mutator: "link", Variation: "shared"},
2776 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002777
2778 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002779 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002780 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002781 {Mutator: "link", Variation: "shared"},
2782 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002783 actx.AddVariationDependencies([]blueprint.Variation{
2784 {Mutator: "version", Variation: version},
2785 {Mutator: "link", Variation: "shared"},
2786 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002787
2788 if vndkdep := c.vndkdep; vndkdep != nil {
2789 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002790 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002791 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002792 {Mutator: "link", Variation: "shared"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002793 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002794 }
2795 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002796
Vinh Tran367d89d2023-04-28 11:21:25 -04002797 if len(deps.AidlLibs) > 0 {
2798 actx.AddDependency(
2799 c,
2800 aidlLibraryTag,
2801 deps.AidlLibs...,
2802 )
2803 }
2804
Kiyoung Kimee58c932022-10-25 22:59:41 +09002805 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002806}
Colin Cross21b9a242015-03-24 14:15:58 -07002807
Colin Crosse40b4ea2018-10-02 22:25:58 -07002808func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002809 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002810 c.beginMutator(ctx)
2811 }
2812}
2813
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002814// Whether a module can link to another module, taking into
2815// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002816func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002817 tag blueprint.DependencyTag) {
2818
2819 switch t := tag.(type) {
2820 case dependencyTag:
2821 if t != vndkExtDepTag {
2822 return
2823 }
2824 case libraryDependencyTag:
2825 default:
2826 return
2827 }
2828
Ivan Lozanof9e21722020-12-02 09:00:51 -05002829 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002830 // Host code is not restricted
2831 return
2832 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002833
2834 // VNDK is cc.Module supported only for now.
2835 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002836 // Though allowed dependency is limited by the image mutator,
2837 // each vendor and product module needs to check link-type
2838 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002839 if ccTo, ok := to.(*Module); ok {
2840 if ccFrom.vndkdep != nil {
2841 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2842 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002843 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002844 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002845 }
2846 return
2847 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002848 // TODO(b/244244438) : Remove this once all variants are implemented
2849 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2850 return
2851 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002852 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002853 // Platform code can link to anything
2854 return
2855 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002856 if from.InRamdisk() {
2857 // Ramdisk code is not NDK
2858 return
2859 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002860 if from.InVendorRamdisk() {
2861 // Vendor ramdisk code is not NDK
2862 return
2863 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002864 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002865 // Recovery code is not NDK
2866 return
2867 }
Colin Cross31076b32020-10-23 17:22:06 -07002868 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002869 if c.NdkPrebuiltStl() {
2870 // These are allowed, but they don't set sdk_version
2871 return
2872 }
2873 if c.StubDecorator() {
2874 // These aren't real libraries, but are the stub shared libraries that are included in
2875 // the NDK.
2876 return
2877 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002878 if c.isImportedApiLibrary() {
2879 // Imported library from the API surface is a stub library built against interface definition.
2880 return
2881 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002882 }
Logan Chien834b9a62019-01-14 15:39:03 +08002883
Ivan Lozano52767be2019-10-18 14:49:46 -07002884 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002885 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2886 // to link to libc++ (non-NDK and without sdk_version).
2887 return
2888 }
2889
Ivan Lozano52767be2019-10-18 14:49:46 -07002890 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002891 // NDK code linking to platform code is never okay.
2892 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002893 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002894 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002895 }
2896
2897 // At this point we know we have two NDK libraries, but we need to
2898 // check that we're not linking against anything built against a higher
2899 // API level, as it is only valid to link against older or equivalent
2900 // APIs.
2901
Inseob Kim01a28722018-04-11 09:48:45 +09002902 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002903 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002904 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002905 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002906 // Current can't be linked against by anything else.
2907 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002908 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002909 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002910 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002911 if err != nil {
2912 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002913 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002914 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002915 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002916 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002917 if err != nil {
2918 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002919 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002920 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002921 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002922
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002923 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002924 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002925 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002926 }
2927 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002928 }
Dan Albert202fe492017-12-15 13:56:59 -08002929
2930 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002931 fromStl := from.SelectedStl()
2932 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002933 if fromStl == "" || toStl == "" {
2934 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002935 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002936 // We can be permissive with the system "STL" since it is only the C++
2937 // ABI layer, but in the future we should make sure that everyone is
2938 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002939 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002940 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002941 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2942 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002943 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002944}
2945
Jooyung Han479ca172020-10-19 18:51:07 +09002946func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2947 if c, ok := ctx.Module().(*Module); ok {
2948 ctx.VisitDirectDeps(func(dep android.Module) {
2949 depTag := ctx.OtherModuleDependencyTag(dep)
2950 ccDep, ok := dep.(LinkableInterface)
2951 if ok {
2952 checkLinkType(ctx, c, ccDep, depTag)
2953 }
2954 })
2955 }
2956}
2957
Jiyong Park5fb8c102018-04-09 12:03:06 +09002958// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002959// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2960// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002961// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002962func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2963 check := func(child, parent android.Module) bool {
2964 to, ok := child.(*Module)
2965 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002966 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002967 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002968
Jooyung Hana70f0672019-01-18 15:20:43 +09002969 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2970 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002971 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002972
Jiyong Park0474e1f2021-01-14 14:26:06 +09002973 // These dependencies are not excercised at runtime. Tracking these will give us
2974 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002975 depTag := ctx.OtherModuleDependencyTag(child)
2976 if IsHeaderDepTag(depTag) {
2977 return false
2978 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002979 if depTag == staticVariantTag {
2980 return false
2981 }
2982 if depTag == stubImplDepTag {
2983 return false
2984 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002985 if depTag == android.RequiredDepTag {
2986 return false
2987 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002988
Justin Yun63e9ec72020-10-29 16:49:43 +09002989 // Even if target lib has no vendor variant, keep checking dependency
2990 // graph in case it depends on vendor_available or product_available
2991 // but not double_loadable transtively.
2992 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002993 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002994 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002995
Jiyong Park0474e1f2021-01-14 14:26:06 +09002996 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2997 // one.
2998 if Bool(to.VendorProperties.Double_loadable) {
2999 return true
3000 }
3001
Ivan Lozanod7586b62021-04-01 09:49:36 -04003002 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09003003 return false
3004 }
3005
Jooyung Hana70f0672019-01-18 15:20:43 +09003006 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
3007 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09003008 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09003009 return false
3010 }
3011 if module, ok := ctx.Module().(*Module); ok {
3012 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09003013 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09003014 ctx.WalkDeps(check)
3015 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09003016 }
3017 }
3018}
3019
Yu Liue4312402023-01-18 09:15:31 -08003020func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
3021 // For the dependency from platform to apex, use the latest stubs
3022 apexSdkVersion := android.FutureApiLevel
3023 if !apexInfo.IsForPlatform() {
3024 apexSdkVersion = apexInfo.MinSdkVersion
3025 }
3026
3027 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
3028 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
3029 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
3030 // (b/144430859)
3031 apexSdkVersion = android.FutureApiLevel
3032 }
3033
3034 return apexSdkVersion
3035}
3036
Colin Crossc99deeb2016-04-11 15:06:20 -07003037// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07003038func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08003039 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08003040
Colin Cross0de8a1e2020-09-18 14:15:30 -07003041 var directStaticDeps []StaticLibraryInfo
3042 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07003043
Colin Cross0de8a1e2020-09-18 14:15:30 -07003044 reexportExporter := func(exporter FlagExporterInfo) {
3045 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
3046 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
3047 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
3048 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
3049 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09003050 }
3051
Colin Crossff694a82023-12-13 15:54:49 -08003052 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08003053 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09003054
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003055 skipModuleList := map[string]bool{}
3056
3057 var apiImportInfo multitree.ApiImportInfo
3058 hasApiImportInfo := false
3059
3060 ctx.VisitDirectDeps(func(dep android.Module) {
3061 if dep.Name() == "api_imports" {
Colin Cross313aa542023-12-13 13:47:44 -08003062 apiImportInfo, _ = android.OtherModuleProvider(ctx, dep, multitree.ApiImportsProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003063 hasApiImportInfo = true
3064 }
3065 })
3066
3067 if hasApiImportInfo {
3068 targetStubModuleList := map[string]string{}
3069 targetOrigModuleList := map[string]string{}
3070
3071 // Search for dependency which both original module and API imported library with APEX stub exists
3072 ctx.VisitDirectDeps(func(dep android.Module) {
3073 depName := ctx.OtherModuleName(dep)
3074 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
3075 targetStubModuleList[apiLibrary] = depName
3076 }
3077 })
3078 ctx.VisitDirectDeps(func(dep android.Module) {
3079 depName := ctx.OtherModuleName(dep)
3080 if origLibrary, ok := targetStubModuleList[depName]; ok {
3081 targetOrigModuleList[origLibrary] = depName
3082 }
3083 })
3084
3085 // Decide which library should be used between original and API imported library
3086 ctx.VisitDirectDeps(func(dep android.Module) {
3087 depName := ctx.OtherModuleName(dep)
3088 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00003089 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003090 skipModuleList[depName] = true
3091 } else {
3092 skipModuleList[apiLibrary] = true
3093 }
3094 }
3095 })
3096 }
3097
Colin Crossd11fcda2017-10-23 17:59:01 -07003098 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003099 depName := ctx.OtherModuleName(dep)
3100 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07003101
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003102 if _, ok := skipModuleList[depName]; ok {
3103 // skip this module because original module or API imported module matching with this should be used instead.
3104 return
3105 }
3106
Dan Willemsen47450072021-10-19 20:24:49 -07003107 if depTag == android.DarwinUniversalVariantTag {
3108 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3109 return
3110 }
3111
Vinh Tran367d89d2023-04-28 11:21:25 -04003112 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08003113 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04003114 depPaths.AidlLibraryInfos = append(
3115 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08003116 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04003117 )
3118 }
3119 }
3120
Ivan Lozano52767be2019-10-18 14:49:46 -07003121 ccDep, ok := dep.(LinkableInterface)
3122 if !ok {
3123
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003124 // handling for a few module types that aren't cc Module but that are also supported
3125 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003126 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003127 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003128 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3129 genRule.GeneratedSourceFiles()...)
3130 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003131 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003132 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003133 // Support exported headers from a generated_sources dependency
3134 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003135 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003136 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003137 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003138 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003139 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003140 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003141 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003142 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003143 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3144 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003145 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003146 // 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 +09003147 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003148
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003149 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003150 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003151 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003152 }
Colin Crosscef792e2021-06-11 18:01:26 -07003153 case CrtBeginDepTag:
3154 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3155 case CrtEndDepTag:
3156 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003157 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003158 return
3159 }
3160
Colin Crossfe17f6f2019-03-28 19:30:56 -07003161 if depTag == android.ProtoPluginDepTag {
3162 return
3163 }
3164
Jiyong Park8bcf3c62024-03-18 18:37:10 +09003165 if depTag == android.RequiredDepTag {
3166 return
3167 }
3168
Colin Crossd11fcda2017-10-23 17:59:01 -07003169 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003170 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3171 return
3172 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003173 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003174 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3175 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003176 return
3177 }
3178
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003179 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003180 // Skip reused objects for stub libraries, they use their own stub object file instead.
3181 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3182 // version mutator, so the stubs variant is created from the shared variant that
3183 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003184 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003185 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003186 objs := staticAnalogue.ReuseObjects
3187 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003188 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003189 reexportExporter(depExporterInfo)
3190 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003191 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003192 }
3193
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08003194 if depTag == llndkHeaderLibTag {
3195 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3196 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
3197 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3198 }
3199
Colin Cross6e511a92020-07-27 21:26:48 -07003200 linkFile := ccDep.OutputFile()
3201
3202 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3203 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003204 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003205 return
3206 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003207
Jiyong Parke3867542020-12-03 17:28:25 +09003208 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3209 return
3210 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003211 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3212 return
3213 }
Jiyong Parke3867542020-12-03 17:28:25 +09003214
Colin Cross313aa542023-12-13 13:47:44 -08003215 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003216
Colin Cross6e511a92020-07-27 21:26:48 -07003217 var ptr *android.Paths
3218 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003219
Colin Cross6e511a92020-07-27 21:26:48 -07003220 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003221
Colin Cross6e511a92020-07-27 21:26:48 -07003222 switch {
3223 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003224 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003225 if !ctx.Config().AllowMissingDependencies() {
3226 ctx.ModuleErrorf("module %q is not a header library", depName)
3227 } else {
3228 ctx.AddMissingDependencies([]string{depName})
3229 }
3230 return
3231 }
Colin Cross6e511a92020-07-27 21:26:48 -07003232 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003233 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003234 if !ctx.Config().AllowMissingDependencies() {
3235 ctx.ModuleErrorf("module %q is not a shared library", depName)
3236 } else {
3237 ctx.AddMissingDependencies([]string{depName})
3238 }
3239 return
3240 }
Jiyong Parke3867542020-12-03 17:28:25 +09003241
Jiyong Park7d55b612021-06-11 17:22:09 +09003242 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3243 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003244
Jiyong Park1ad8e162020-12-01 23:40:09 +09003245 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3246 // linkFile, depFile, and ptr.
3247 if c.IsStubs() {
3248 break
3249 }
3250
Colin Cross0de8a1e2020-09-18 14:15:30 -07003251 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3252 depFile = sharedLibraryInfo.TableOfContents
3253
Colin Cross6e511a92020-07-27 21:26:48 -07003254 ptr = &depPaths.SharedLibs
3255 switch libDepTag.Order {
3256 case earlyLibraryDependency:
3257 ptr = &depPaths.EarlySharedLibs
3258 depPtr = &depPaths.EarlySharedLibsDeps
3259 case normalLibraryDependency:
3260 ptr = &depPaths.SharedLibs
3261 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003262 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003263 case lateLibraryDependency:
3264 ptr = &depPaths.LateSharedLibs
3265 depPtr = &depPaths.LateSharedLibsDeps
3266 default:
3267 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003268 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003269
3270 case libDepTag.rlib():
3271 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3272 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
3273 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3274 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3275 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3276
Colin Cross6e511a92020-07-27 21:26:48 -07003277 case libDepTag.static():
Colin Cross313aa542023-12-13 13:47:44 -08003278 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3279 if !isStaticLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003280 if !ctx.Config().AllowMissingDependencies() {
3281 ctx.ModuleErrorf("module %q is not a static library", depName)
3282 } else {
3283 ctx.AddMissingDependencies([]string{depName})
3284 }
3285 return
3286 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003287
3288 // Stubs lib doesn't link to the static lib dependencies. Don't set
3289 // linkFile, depFile, and ptr.
3290 if c.IsStubs() {
3291 break
3292 }
3293
Colin Cross0de8a1e2020-09-18 14:15:30 -07003294 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003295 if libDepTag.wholeStatic {
3296 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003297 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3298 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003299 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003300 // This case normally catches prebuilt static
3301 // libraries, but it can also occur when
3302 // AllowMissingDependencies is on and the
3303 // dependencies has no sources of its own
3304 // but has a whole_static_libs dependency
3305 // on a missing library. We want to depend
3306 // on the .a file so that there is something
3307 // in the dependency tree that contains the
3308 // error rule for the missing transitive
3309 // dependency.
3310 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003311 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003312 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3313 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003314 } else {
3315 switch libDepTag.Order {
3316 case earlyLibraryDependency:
3317 panic(fmt.Errorf("early static libs not suppported"))
3318 case normalLibraryDependency:
3319 // static dependencies will be handled separately so they can be ordered
3320 // using transitive dependencies.
3321 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003322 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003323 case lateLibraryDependency:
3324 ptr = &depPaths.LateStaticLibs
3325 default:
3326 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003327 }
3328 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003329
3330 // We re-export the Rust static_rlibs so rlib dependencies don't need to be redeclared by cc_library_static dependents.
3331 // E.g. libfoo (cc_library_static) depends on libfoo.ffi (a rust_ffi rlib), libbar depending on libfoo shouldn't have to also add libfoo.ffi to static_rlibs.
3332 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3333 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3334
Colin Cross3e5e7782022-06-17 22:17:05 +00003335 if libDepTag.unexportedSymbols {
3336 depPaths.LdFlags = append(depPaths.LdFlags,
3337 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3338 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003339 }
3340
Colin Cross6e511a92020-07-27 21:26:48 -07003341 if libDepTag.static() && !libDepTag.wholeStatic {
3342 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3343 ctx.ModuleErrorf("module %q not a static library", depName)
3344 return
3345 }
Logan Chien43d34c32017-12-20 01:17:32 +08003346
Colin Cross6e511a92020-07-27 21:26:48 -07003347 // When combining coverage files for shared libraries and executables, coverage files
3348 // in static libraries act as if they were whole static libraries. The same goes for
3349 // source based Abi dump files.
3350 if c, ok := ccDep.(*Module); ok {
3351 staticLib := c.linker.(libraryInterface)
3352 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3353 staticLib.objs().coverageFiles...)
3354 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3355 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003356 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003357 // Handle non-CC modules here
3358 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003359 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003360 }
3361 }
3362
Colin Cross6e511a92020-07-27 21:26:48 -07003363 if ptr != nil {
3364 if !linkFile.Valid() {
3365 if !ctx.Config().AllowMissingDependencies() {
3366 ctx.ModuleErrorf("module %q missing output file", depName)
3367 } else {
3368 ctx.AddMissingDependencies([]string{depName})
3369 }
3370 return
3371 }
3372 *ptr = append(*ptr, linkFile.Path())
3373 }
3374
3375 if depPtr != nil {
3376 dep := depFile
3377 if !dep.Valid() {
3378 dep = linkFile
3379 }
3380 *depPtr = append(*depPtr, dep.Path())
3381 }
3382
Colin Cross0de8a1e2020-09-18 14:15:30 -07003383 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3384 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3385 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3386 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003387 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3388
3389 // Only re-export RustRlibDeps for cc static libs
3390 if c.static() {
3391 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3392 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003393
3394 if libDepTag.reexportFlags {
3395 reexportExporter(depExporterInfo)
3396 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3397 // Re-exported shared library headers must be included as well since they can help us with type information
3398 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003399 c.sabi.Properties.ReexportedIncludes = append(
3400 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003401 c.sabi.Properties.ReexportedSystemIncludes = append(
3402 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003403 }
3404
Spandan Das3faa7922024-02-26 19:42:32 +00003405 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003406 switch {
3407 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003408 c.Properties.AndroidMkHeaderLibs = append(
3409 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003410 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003411 if lib := moduleLibraryInterface(dep); lib != nil {
3412 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003413 // Add the dependency to the APEX(es) providing the library so that
3414 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003415 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003416 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003417 c.Properties.ApexesProvidingSharedLibs = append(
3418 c.Properties.ApexesProvidingSharedLibs, an)
3419 }
3420 }
3421 }
3422
3423 // Note: the order of libs in this list is not important because
3424 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003425 c.Properties.AndroidMkSharedLibs = append(
3426 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003427 case libDepTag.static():
3428 if libDepTag.wholeStatic {
3429 c.Properties.AndroidMkWholeStaticLibs = append(
3430 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3431 } else {
3432 c.Properties.AndroidMkStaticLibs = append(
3433 c.Properties.AndroidMkStaticLibs, makeLibName)
3434 }
3435 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003436 } else if !c.IsStubs() {
3437 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3438
Colin Cross6e511a92020-07-27 21:26:48 -07003439 switch depTag {
3440 case runtimeDepTag:
3441 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003442 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003443 case objDepTag:
3444 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3445 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003446 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003447 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003448 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003449 case dynamicLinkerDepTag:
3450 depPaths.DynamicLinker = linkFile
3451 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003452 }
Colin Crossca860ac2016-01-04 14:34:37 -08003453 })
3454
Jeff Gaston294356f2017-09-27 17:05:30 -07003455 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003456 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3457 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3458 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003459
Colin Crossdd84e052017-05-17 13:44:16 -07003460 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003461 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003462 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3463 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003464 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003465 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3466
Jiyong Park74955042019-10-22 20:19:51 +09003467 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3468 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003469 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003470 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003471 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003472 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003473
3474 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003475 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003476 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003477 }
Colin Crossdd84e052017-05-17 13:44:16 -07003478
Colin Crossca860ac2016-01-04 14:34:37 -08003479 return depPaths
3480}
3481
Spandan Das604f3762023-03-16 22:51:40 +00003482func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003483 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003484 thisModule, ok := ctx.Module().(android.ApexModule)
3485 if !ok {
3486 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3487 }
3488
Kiyoung Kimaa394802024-01-08 12:55:45 +09003489 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003490 bootstrap := false
3491 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3492 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3493 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003494 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003495 bootstrap = linkable.Bootstrap()
3496 }
3497
Colin Crossff694a82023-12-13 15:54:49 -08003498 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003499
3500 useStubs := false
3501
Kiyoung Kimaa394802024-01-08 12:55:45 +09003502 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003503 if !apexInfo.IsForPlatform() {
3504 // For platform libraries, use current version of LLNDK
3505 // If this is for use_vendor apex we will apply the same rules
3506 // of apex sdk enforcement below to choose right version.
3507 useStubs = true
3508 }
3509 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3510 // If not building for APEX or the containing APEX allows the use of
3511 // platform APIs, use stubs only when it is from an APEX (and not from
3512 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3513 // bootstrap modules, always link to non-stub variant
3514 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3515
3516 isApexImportedApiLibrary := false
3517
3518 if cc, ok := dep.(*Module); ok {
3519 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3520 if apiLibrary.hasApexStubs() {
3521 isApexImportedApiLibrary = true
3522 }
3523 }
3524 }
3525
3526 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3527
3528 if useStubs {
3529 // Another exception: if this module is a test for an APEX, then
3530 // it is linked with the non-stub variant of a module in the APEX
3531 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003532 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003533 for _, apexContents := range testFor.ApexContents {
3534 if apexContents.DirectlyInApex(depName) {
3535 useStubs = false
3536 break
3537 }
3538 }
3539 }
3540 if useStubs {
3541 // Yet another exception: If this module and the dependency are
3542 // available to the same APEXes then skip stubs between their
3543 // platform variants. This complements the test_for case above,
3544 // which avoids the stubs on a direct APEX library dependency, by
3545 // avoiding stubs for indirect test dependencies as well.
3546 //
3547 // TODO(b/183882457): This doesn't work if the two libraries have
3548 // only partially overlapping apex_available. For that test_for
3549 // modules would need to be split into APEX variants and resolved
3550 // separately for each APEX they have access to.
3551 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3552 useStubs = false
3553 }
3554 }
3555 } else {
3556 // If building for APEX, use stubs when the parent is in any APEX that
3557 // the child is not in.
3558 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3559 }
3560
3561 return useStubs
3562}
3563
3564// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3565// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3566// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3567// has different level of updatability. For example, if a library foo in an APEX depends on a
3568// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3569// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3570// same APEX as foo, the non-stub variant of bar is used.
3571func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3572 depTag := ctx.OtherModuleDependencyTag(dep)
3573 libDepTag, ok := depTag.(libraryDependencyTag)
3574 if !ok || !libDepTag.shared() {
3575 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3576 }
3577
Colin Cross313aa542023-12-13 13:47:44 -08003578 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3579 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3580 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003581
3582 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003583 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003584 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003585 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3586 toUse := stubs[len(stubs)-1]
3587 sharedLibraryInfo = toUse.SharedLibraryInfo
3588 depExporterInfo = toUse.FlagExporterInfo
3589 }
3590 }
3591 return sharedLibraryInfo, depExporterInfo
3592}
3593
Colin Cross0de8a1e2020-09-18 14:15:30 -07003594// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3595// to match the topological order of the dependency tree, including any static analogues of
3596// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3597// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003598func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3599 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003600 var staticPaths android.Paths
3601 for _, staticDep := range staticDeps {
3602 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3603 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3604 }
3605 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003606 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3607 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003608 }
3609 }
3610 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3611
3612 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3613
3614 // reorder the dependencies based on transitive dependencies
3615 staticPaths = android.FirstUniquePaths(staticPaths)
3616 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3617
3618 if len(orderedStaticPaths) != len(staticPaths) {
3619 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3620 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3621 }
3622
3623 return orderedStaticPaths, transitiveStaticLibs
3624}
3625
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003626// BaseLibName trims known prefixes and suffixes
3627func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003628 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3629 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003630 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003631 return libName
3632}
3633
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003634func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003635 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003636 ccDepModule, _ := ccDep.(*Module)
3637 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003638 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003639
Justin Yuncbca3732021-02-03 19:24:13 +09003640 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003641 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003642 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003643 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003644
Ivan Lozanod1dec542021-05-26 15:33:11 -04003645 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003646 }
3647 }
3648
Kiyoung Kim22152f62024-05-24 10:45:28 +09003649 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003650 // The vendor and product modules in Make will have been renamed to not conflict with the
3651 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003652 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003653 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003654 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003655 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003656 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003657 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003658 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003659 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003660 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003661 } else {
3662 return libName
3663 }
3664}
3665
Colin Crossca860ac2016-01-04 14:34:37 -08003666func (c *Module) InstallInData() bool {
3667 if c.installer == nil {
3668 return false
3669 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003670 return c.installer.inData()
3671}
3672
3673func (c *Module) InstallInSanitizerDir() bool {
3674 if c.installer == nil {
3675 return false
3676 }
3677 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003678 return true
3679 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003680 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003681}
3682
Yifan Hong1b3348d2020-01-21 15:53:22 -08003683func (c *Module) InstallInRamdisk() bool {
3684 return c.InRamdisk()
3685}
3686
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003687func (c *Module) InstallInVendorRamdisk() bool {
3688 return c.InVendorRamdisk()
3689}
3690
Jiyong Parkf9332f12018-02-01 00:54:12 +09003691func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003692 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003693}
3694
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003695func (c *Module) MakeUninstallable() {
3696 if c.installer == nil {
3697 c.ModuleBase.MakeUninstallable()
3698 return
3699 }
3700 c.installer.makeUninstallable(c)
3701}
3702
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003703func (c *Module) HostToolPath() android.OptionalPath {
3704 if c.installer == nil {
3705 return android.OptionalPath{}
3706 }
3707 return c.installer.hostToolPath()
3708}
3709
Nan Zhangd4e641b2017-07-12 12:55:28 -07003710func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3711 return c.outputFile
3712}
3713
Colin Cross41955e82019-05-29 14:40:35 -07003714func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3715 switch tag {
3716 case "":
3717 if c.outputFile.Valid() {
3718 return android.Paths{c.outputFile.Path()}, nil
3719 }
3720 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003721 case "unstripped":
3722 if c.linker != nil {
3723 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3724 }
3725 return nil, nil
Wei Li5f5d2712023-12-11 15:40:29 -08003726 case "stripped_all":
3727 if c.linker != nil {
3728 return android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), nil
3729 }
3730 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003731 default:
3732 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003733 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003734}
3735
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003736func (c *Module) static() bool {
3737 if static, ok := c.linker.(interface {
3738 static() bool
3739 }); ok {
3740 return static.static()
3741 }
3742 return false
3743}
3744
Jiyong Park379de2f2018-12-19 02:47:14 +09003745func (c *Module) staticBinary() bool {
3746 if static, ok := c.linker.(interface {
3747 staticBinary() bool
3748 }); ok {
3749 return static.staticBinary()
3750 }
3751 return false
3752}
3753
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003754func (c *Module) testBinary() bool {
3755 if test, ok := c.linker.(interface {
3756 testBinary() bool
3757 }); ok {
3758 return test.testBinary()
3759 }
3760 return false
3761}
3762
Jingwen Chen537242c2022-08-24 11:53:27 +00003763func (c *Module) testLibrary() bool {
3764 if test, ok := c.linker.(interface {
3765 testLibrary() bool
3766 }); ok {
3767 return test.testLibrary()
3768 }
3769 return false
3770}
3771
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003772func (c *Module) benchmarkBinary() bool {
3773 if b, ok := c.linker.(interface {
3774 benchmarkBinary() bool
3775 }); ok {
3776 return b.benchmarkBinary()
3777 }
3778 return false
3779}
3780
3781func (c *Module) fuzzBinary() bool {
3782 if f, ok := c.linker.(interface {
3783 fuzzBinary() bool
3784 }); ok {
3785 return f.fuzzBinary()
3786 }
3787 return false
3788}
3789
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003790// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3791func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003792 if h, ok := c.linker.(interface {
3793 header() bool
3794 }); ok {
3795 return h.header()
3796 }
3797 return false
3798}
3799
Ivan Lozanod7586b62021-04-01 09:49:36 -04003800func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003801 if b, ok := c.linker.(interface {
3802 binary() bool
3803 }); ok {
3804 return b.binary()
3805 }
3806 return false
3807}
3808
Justin Yun5e035862021-06-29 20:50:37 +09003809func (c *Module) StaticExecutable() bool {
3810 if b, ok := c.linker.(*binaryDecorator); ok {
3811 return b.static()
3812 }
3813 return false
3814}
3815
Ivan Lozanod7586b62021-04-01 09:49:36 -04003816func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003817 if o, ok := c.linker.(interface {
3818 object() bool
3819 }); ok {
3820 return o.object()
3821 }
3822 return false
3823}
3824
Kiyoung Kim37693d02024-04-04 09:56:15 +09003825func (m *Module) Dylib() bool {
3826 return false
3827}
3828
3829func (m *Module) Rlib() bool {
3830 return false
3831}
3832
Ivan Lozanof9e21722020-12-02 09:00:51 -05003833func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003834 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003835 if c.IsLlndk() {
3836 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003837 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003838 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003839 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003840 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003841 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003842 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003843 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003844 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003845 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003846 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003847 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003848 return "native:product"
3849 }
Jooyung Han38002912019-05-16 04:01:54 +09003850 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003851 } else if c.InRamdisk() {
3852 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003853 } else if c.InVendorRamdisk() {
3854 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003855 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003856 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003857 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003858 return "native:ndk:none:none"
3859 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3860 //family, link := getNdkStlFamilyAndLinkType(c)
3861 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3862 } else {
3863 return "native:platform"
3864 }
3865}
3866
Jiyong Park9d452992018-10-03 00:38:19 +09003867// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003868// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003869func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003870 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003871 // Stub libs and prebuilt libs in a versioned SDK are not
3872 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003873 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003874 } else if _, ok := c.linker.(testPerSrc); ok {
3875 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003876 }
3877 return false
3878}
3879
Jiyong Parka90ca002019-10-07 15:47:24 +09003880func (c *Module) AvailableFor(what string) bool {
3881 if linker, ok := c.linker.(interface {
3882 availableFor(string) bool
3883 }); ok {
3884 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3885 } else {
3886 return c.ApexModuleBase.AvailableFor(what)
3887 }
3888}
3889
Jiyong Park62304bb2020-04-13 16:19:48 +09003890func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003891 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003892}
3893
Paul Duffin0cb37b92020-03-04 14:52:46 +00003894func (c *Module) EverInstallable() bool {
3895 return c.installer != nil &&
3896 // Check to see whether the module is actually ever installable.
3897 c.installer.everInstallable()
3898}
3899
Ivan Lozanod7586b62021-04-01 09:49:36 -04003900func (c *Module) PreventInstall() bool {
3901 return c.Properties.PreventInstall
3902}
3903
3904func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003905 if c.library != nil {
3906 if i := c.library.installable(); i != nil {
3907 return i
3908 }
3909 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003910 return c.Properties.Installable
3911}
3912
3913func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003914 ret := c.EverInstallable() &&
3915 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003916 proptools.BoolDefault(c.Installable(), true) &&
3917 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003918
3919 // The platform variant doesn't need further condition. Apex variants however might not
3920 // be installable because it will likely to be included in the APEX and won't appear
3921 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003922 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003923 return ret
3924 }
3925
3926 // Special case for modules that are configured to be installed to /data, which includes
3927 // test modules. For these modules, both APEX and non-APEX variants are considered as
3928 // installable. This is because even the APEX variants won't be included in the APEX, but
3929 // will anyway be installed to /data/*.
3930 // See b/146995717
3931 if c.InstallInData() {
3932 return ret
3933 }
3934
3935 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003936}
3937
Logan Chien41eabe62019-04-10 13:33:58 +08003938func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3939 if c.linker != nil {
3940 if library, ok := c.linker.(*libraryDecorator); ok {
3941 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3942 }
3943 }
3944}
3945
Jiyong Park45bf82e2020-12-15 22:29:02 +09003946var _ android.ApexModule = (*Module)(nil)
3947
3948// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003949func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003950 depTag := ctx.OtherModuleDependencyTag(dep)
3951 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3952
3953 if cc, ok := dep.(*Module); ok {
3954 if cc.HasStubsVariants() {
3955 if isLibDepTag && libDepTag.shared() {
3956 // dynamic dep to a stubs lib crosses APEX boundary
3957 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003958 }
Colin Cross6e511a92020-07-27 21:26:48 -07003959 if IsRuntimeDepTag(depTag) {
3960 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003961 return false
3962 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003963 }
Zhijun Heec285872021-04-24 10:47:08 -07003964 if cc.IsLlndk() {
3965 return false
3966 }
Colin Crossaac32222020-07-29 12:51:56 -07003967 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003968 // shared_lib dependency from a static lib is considered as crossing
3969 // the APEX boundary because the dependency doesn't actually is
3970 // linked; the dependency is used only during the compilation phase.
3971 return false
3972 }
Jiyong Parke3867542020-12-03 17:28:25 +09003973
3974 if isLibDepTag && libDepTag.excludeInApex {
3975 return false
3976 }
Colin Cross6e511a92020-07-27 21:26:48 -07003977 }
Colin Crossc1b36442021-05-06 13:42:48 -07003978 if depTag == stubImplDepTag {
3979 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003980 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003981 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003982 if depTag == staticVariantTag {
3983 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3984 // actually mean that the static lib (and its dependencies) are copied into the
3985 // APEX.
3986 return false
3987 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003988 return true
3989}
3990
Jiyong Park45bf82e2020-12-15 22:29:02 +09003991// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003992func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3993 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003994 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3995 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3996 return nil
3997 }
Jooyung Han749dc692020-04-15 11:03:39 +09003998 // We don't check for prebuilt modules
3999 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
4000 return nil
4001 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09004002
Jooyung Han749dc692020-04-15 11:03:39 +09004003 minSdkVersion := c.MinSdkVersion()
4004 if minSdkVersion == "apex_inherit" {
4005 return nil
4006 }
4007 if minSdkVersion == "" {
4008 // JNI libs within APK-in-APEX fall into here
4009 // Those are okay to set sdk_version instead
4010 // We don't have to check if this is a SDK variant because
4011 // non-SDK variant resets sdk_version, which works too.
4012 minSdkVersion = c.SdkVersion()
4013 }
Dan Albertc8060532020-07-22 22:32:17 -07004014 if minSdkVersion == "" {
4015 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
4016 }
4017 // Not using nativeApiLevelFromUser because the context here is not
4018 // necessarily a native context.
4019 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09004020 if err != nil {
4021 return err
4022 }
Dan Albertc8060532020-07-22 22:32:17 -07004023
Colin Cross8ca61c12022-10-06 21:00:14 -07004024 // A dependency only needs to support a min_sdk_version at least
4025 // as high as the api level that the architecture was introduced in.
4026 // This allows introducing new architectures in the platform that
4027 // need to be included in apexes that normally require an older
4028 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08004029 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07004030 if sdkVersion.LessThan(minApiForArch) {
4031 sdkVersion = minApiForArch
4032 }
4033
Dan Albertc8060532020-07-22 22:32:17 -07004034 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09004035 return fmt.Errorf("newer SDK(%v)", ver)
4036 }
4037 return nil
4038}
4039
Paul Duffinb5769c12021-05-12 16:16:51 +01004040// Implements android.ApexModule
4041func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
4042 // stub libraries and native bridge libraries are always available to platform
4043 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
4044}
4045
Jooyung Han91f92032022-02-04 12:36:33 +09004046// Overrides android.ApexModuleBase.UniqueApexVariations
4047func (c *Module) UniqueApexVariations() bool {
4048 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
4049 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
4050 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09004051 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09004052 return c.UseVndk() && c.IsVndk()
4053}
4054
Inseob Kima1888ce2022-10-04 14:42:02 +09004055func (c *Module) overriddenModules() []string {
4056 if o, ok := c.linker.(overridable); ok {
4057 return o.overriddenModules()
4058 }
4059 return nil
4060}
4061
Liz Kammer35ca77e2021-12-22 15:31:40 -05004062type moduleType int
4063
4064const (
4065 unknownType moduleType = iota
4066 binary
4067 object
4068 fullLibrary
4069 staticLibrary
4070 sharedLibrary
4071 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00004072 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00004073 ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00004074 ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05004075)
4076
4077func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00004078 if c.testBinary() {
4079 // testBinary is also a binary, so this comes before the c.Binary()
4080 // conditional. A testBinary has additional implicit dependencies and
4081 // other test-only semantics.
4082 return testBin
4083 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004084 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004085 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004086 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00004087 } else if c.testLibrary() {
4088 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
4089 // will let them add implicit compile deps on gtest, for example.
4090 //
Liz Kammerefc51d92023-04-21 15:11:25 -04004091 // For now, treat them as regular libraries.
4092 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004093 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05004094 static := false
4095 shared := false
4096 if library, ok := c.linker.(*libraryDecorator); ok {
4097 static = library.MutatedProperties.BuildStatic
4098 shared = library.MutatedProperties.BuildShared
4099 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
4100 static = library.MutatedProperties.BuildStatic
4101 shared = library.MutatedProperties.BuildShared
4102 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004103 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004104 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004105 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004106 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004107 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004108 return staticLibrary
4109 }
4110 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00004111 } else if c.isNDKStubLibrary() {
4112 return ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00004113 } else if c.IsNdkPrebuiltStl() {
4114 return ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05004115 }
4116 return unknownType
4117}
4118
Colin Crosscfad1192015-11-02 16:43:11 -08004119// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004120type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004121 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004122 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004123 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08004124}
4125
Patrice Arrudac249c712019-03-19 17:00:29 -07004126// cc_defaults provides a set of properties that can be inherited by other cc
4127// modules. A module can use the properties from a cc_defaults using
4128// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4129// merged (when possible) by prepending the default module's values to the
4130// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004131func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004132 return DefaultsFactory()
4133}
4134
Colin Cross36242852017-06-23 15:06:31 -07004135func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004136 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004137
Colin Cross36242852017-06-23 15:06:31 -07004138 module.AddProperties(props...)
4139 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004140 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004141 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004142 &BaseCompilerProperties{},
4143 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004144 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004145 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004146 &StaticProperties{},
4147 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004148 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004149 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004150 &TestLinkerProperties{},
4151 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004152 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004153 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004154 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004155 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004156 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004157 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004158 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004159 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004160 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004161 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004162 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004163 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004164 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00004165 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004166 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004167 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4168 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004169 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004170 )
Colin Crosscfad1192015-11-02 16:43:11 -08004171
Jooyung Hancc372c52019-09-25 15:18:44 +09004172 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004173
4174 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004175}
4176
Jiyong Park2286afd2020-06-16 21:58:53 +09004177func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004178 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004179}
4180
Kiyoung Kim51279d32022-08-24 14:10:46 +09004181func (c *Module) isImportedApiLibrary() bool {
4182 _, ok := c.linker.(*apiLibraryDecorator)
4183 return ok
4184}
4185
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004186func kytheExtractAllFactory() android.Singleton {
4187 return &kytheExtractAllSingleton{}
4188}
4189
4190type kytheExtractAllSingleton struct {
4191}
4192
4193func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4194 var xrefTargets android.Paths
4195 ctx.VisitAllModules(func(module android.Module) {
4196 if ccModule, ok := module.(xref); ok {
4197 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4198 }
4199 })
4200 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4201 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004202 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004203 }
4204}
4205
Jihoon Kangf78a8902022-09-01 22:47:07 +00004206func (c *Module) Partition() string {
4207 if p, ok := c.installer.(interface {
4208 getPartition() string
4209 }); ok {
4210 return p.getPartition()
4211 }
4212 return ""
4213}
4214
Spandan Das2b6dfb52024-01-19 00:22:22 +00004215type sourceModuleName interface {
4216 sourceModuleName() string
4217}
4218
4219func (c *Module) BaseModuleName() string {
4220 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
4221 // if the prebuilt module sets a source_module_name in Android.bp, use that
4222 return smn.sourceModuleName()
4223 }
4224 return c.ModuleBase.BaseModuleName()
4225}
4226
Colin Cross06a931b2015-10-28 17:23:31 -07004227var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004228var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004229var BoolPtr = proptools.BoolPtr
4230var String = proptools.String
4231var StringPtr = proptools.StringPtr