blob: 5b3647ee493f2ab95669500b617e381123553025 [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 Crossac57a6c2024-06-26 13:09:53 -070051 ctx.Transition("sdk", &sdkTransitionMutator{})
Kiyoung Kim973cb6f2024-04-29 14:14:53 +090052 ctx.BottomUp("llndk", llndkMutator).Parallel()
Colin Cross767819f2024-05-22 14:22:34 -070053 ctx.Transition("link", &linkageTransitionMutator{})
Colin Crossadd04a82024-05-22 09:57:59 -070054 ctx.Transition("version", &versionTransitionMutator{})
Colin Crosse40b4ea2018-10-02 22:25:58 -070055 ctx.BottomUp("begin", BeginMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070056 })
Colin Cross16b23492016-01-06 14:41:07 -080057
Paul Duffin036e7002019-12-19 19:16:28 +000058 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040059 for _, san := range Sanitizers {
60 san.registerMutators(ctx)
61 }
Dan Willemsen581341d2017-02-09 16:16:31 -080062
Colin Cross0b908332019-06-19 23:00:20 -070063 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090064 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080065
Cory Barkera1da26f2022-06-07 20:12:06 +000066 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000067
Colin Crossf5f4ad32024-01-19 15:41:48 -080068 ctx.Transition("coverage", &coverageTransitionMutator{})
Stephen Craneba090d12017-05-09 15:44:35 -070069
Colin Crossd38feb02024-01-23 16:38:06 -080070 ctx.Transition("afdo", &afdoTransitionMutator{})
Yi Kongeb8efc92021-12-09 18:06:29 +080071
Colin Cross33e0c812024-01-23 16:36:07 -080072 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000073
Colin Cross6ac83a82024-01-23 11:23:10 -080074 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +090075
Jooyung Han479ca172020-10-19 18:51:07 +090076 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090077 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070078 })
Colin Crossb98c8b02016-07-29 13:44:28 -070079
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080080 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
81 // sabi mutator needs to be run after apex mutator finishes.
82 ctx.TopDown("sabi_deps", sabiDepsMutator)
83 })
84
LaMont Jones0c10e4d2023-05-16 00:58:37 +000085 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070086}
87
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050088// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
89// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
90// edges to these modules.
91// This object is constructed in DepsMutator, by calling to various module delegates to set
92// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
93// dependencies.
94// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
95// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080096type Deps struct {
97 SharedLibs, LateSharedLibs []string
98 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080099 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800100 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700101
Colin Cross3e5e7782022-06-17 22:17:05 +0000102 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
103 // prevent automatically exporting symbols.
104 UnexportedStaticLibs []string
105
Chris Parsons79d66a52020-06-05 17:26:16 -0400106 // Used for data dependencies adjacent to tests
107 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700108 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400109
Yo Chiang219968c2020-09-22 18:45:04 +0800110 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
111 SystemSharedLibs []string
112
Vinh Tran367d89d2023-04-28 11:21:25 -0400113 // Used by DepMutator to pass aidl_library modules to aidl compiler
114 AidlLibs []string
115
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500116 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800117 StaticUnwinderIfLegacy bool
118
Colin Cross5950f382016-12-13 12:50:57 -0800119 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700120
Colin Cross81413472016-04-11 14:37:39 -0700121 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700122
Dan Willemsenb40aab62016-04-20 14:21:14 -0700123 GeneratedSources []string
124 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900125 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700126
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700127 ReexportGeneratedHeaders []string
128
Colin Crossc465efd2021-06-11 18:00:04 -0700129 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700130
131 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700132 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900133
134 // List of libs that need to be excluded for APEX variant
135 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900136 // List of libs that need to be excluded for non-APEX variant
137 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800138
139 // LLNDK headers for the ABI checker to check LLNDK implementation library.
140 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
141 // The core variant cannot depend on the vendor variant because of the order of CreateVariations.
142 // Instead, the LLNDK implementation depends on the LLNDK header libs.
143 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700144}
145
Ivan Lozano0a468a42024-05-13 21:03:34 -0400146// A struct which to collect flags for rlib dependencies
147type RustRlibDep struct {
148 LibPath android.Path // path to the rlib
149 LinkDirs []string // flags required for dependency (e.g. -L flags)
150 CrateName string // crateNames associated with rlibDeps
151}
152
153func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
154 return a.LibPath == b.LibPath
155}
156
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500157// PathDeps is a struct containing file paths to dependencies of a module.
158// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
159// It's used to construct flags for various build statements (such as for compiling and linking).
160// It is then passed to module decorator functions responsible for registering build statements
161// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800162type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700163 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900164 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700165 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900166 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700167 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700168 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400169 // Paths and crateNames for RustStaticLib dependencies
170 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700171
Colin Cross0de8a1e2020-09-18 14:15:30 -0700172 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossc85750b2022-04-21 12:50:51 -0700173 TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700174
Colin Cross26c34ed2016-09-30 17:10:16 -0700175 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100176 Objs Objects
177 // Paths to .o files in dependencies that provide them. Note that these lists
178 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800179 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700180 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700181
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100182 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
183 // the libs from all whole_static_lib dependencies.
184 WholeStaticLibsFromPrebuilts android.Paths
185
Colin Cross26c34ed2016-09-30 17:10:16 -0700186 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700187 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900188 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700189
Inseob Kimd110f872019-12-06 13:15:38 +0900190 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000191 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900192 IncludeDirs android.Paths
193 SystemIncludeDirs android.Paths
194 ReexportedDirs android.Paths
195 ReexportedSystemDirs android.Paths
196 ReexportedFlags []string
197 ReexportedGeneratedHeaders android.Paths
198 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400199 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700200
Colin Cross26c34ed2016-09-30 17:10:16 -0700201 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700202 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700203
Dan Willemsena0790e32018-10-12 00:24:23 -0700204 // Path to the dynamic linker binary
205 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700206
207 // For Darwin builds, the path to the second architecture's output that should
208 // be combined with this architectures's output into a FAT MachO file.
209 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400210
211 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
212 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800213
214 // LLNDK headers for the ABI checker to check LLNDK implementation library.
215 LlndkIncludeDirs android.Paths
216 LlndkSystemIncludeDirs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700217}
218
Colin Cross4af21ed2019-11-04 09:37:55 -0800219// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
220// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
221// command line so they can be overridden by the local module flags).
222type LocalOrGlobalFlags struct {
223 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700224 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800225 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700226 CFlags []string // Flags that apply to C and C++ source files
227 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
228 ConlyFlags []string // Flags that apply to C source files
229 CppFlags []string // Flags that apply to C++ source files
230 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700231 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800232}
233
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500234// Flags contains various types of command line flags (and settings) for use in building build
235// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800236type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500237 // Local flags (which individual modules are responsible for). These may override global flags.
238 Local LocalOrGlobalFlags
239 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700240 Global LocalOrGlobalFlags
241 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800242
243 aidlFlags []string // Flags that apply to aidl source files
244 rsFlags []string // Flags that apply to renderscript source files
245 libFlags []string // Flags to add libraries early to the link order
246 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
247 TidyFlags []string // Flags that apply to clang-tidy
248 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700249
Colin Crossc3199482017-03-30 15:03:04 -0700250 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800251 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700252 SystemIncludeFlags []string
253
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800254 Toolchain config.Toolchain
255 Tidy bool // True if ninja .tidy rules should be generated.
256 NeedTidyFiles bool // True if module link should depend on .tidy files
257 GcovCoverage bool // True if coverage files should be generated.
258 SAbiDump bool // True if header abi dumps should be generated.
259 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800260 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800261
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500262 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800263 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500264 // The target-device system path to the dynamic linker.
265 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800266
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700267 CFlagsDeps android.Paths // Files depended on by compiler flags
268 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800269
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500270 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700271 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800272
Colin Cross19878da2019-03-28 14:45:07 -0700273 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700274 protoC bool // Whether to use C instead of C++
275 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700276
277 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200278 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700279}
280
Colin Crossca860ac2016-01-04 14:34:37 -0800281// Properties used to compile all C or C++ modules
282type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700283 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800284 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700285
Yi Kong5786f5c2024-05-28 02:22:34 +0900286 // Aggresively trade performance for smaller binary size.
287 // This should only be used for on-device binaries that are rarely executed and not
288 // performance critical.
289 Optimize_for_size *bool `android:"arch_variant"`
290
Jiyong Parkb35a8192020-08-10 15:59:36 +0900291 // The API level that this module is built against. The APIs of this API level will be
292 // visible at build time, but use of any APIs newer than min_sdk_version will render the
293 // module unloadable on older devices. In the future it will be possible to weakly-link new
294 // APIs, making the behavior match Java: such modules will load on older devices, but
295 // calling new APIs on devices that do not support them will result in a crash.
296 //
297 // This property has the same behavior as sdk_version does for Java modules. For those
298 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
299 // does for Java code.
300 //
301 // In addition, setting this property causes two variants to be built, one for the platform
302 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800303 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700304
Jiyong Parkb35a8192020-08-10 15:59:36 +0900305 // Minimum OS API level supported by this C or C++ module. This property becomes the value
306 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
307 // this property is also used to ensure that the min_sdk_version of the containing module is
308 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
309 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
310 // min_sdk_version of the containing APEX. When the module
311 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900312 Min_sdk_version *string
313
Colin Crossc511bc52020-04-07 16:50:32 +0000314 // If true, always create an sdk variant and don't create a platform variant.
315 Sdk_variant_only *bool
316
Jiyong Parkde866cb2018-12-07 23:08:36 +0900317 AndroidMkSharedLibs []string `blueprint:"mutated"`
318 AndroidMkStaticLibs []string `blueprint:"mutated"`
Ivan Lozano0a468a42024-05-13 21:03:34 -0400319 AndroidMkRlibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900320 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
321 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700322 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900323 HideFromMake bool `blueprint:"mutated"`
324 PreventInstall bool `blueprint:"mutated"`
325 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700326
Yo Chiang219968c2020-09-22 18:45:04 +0800327 // Set by DepsMutator.
328 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
329
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900330 // The name of the image this module is built for
331 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200332
333 // The VNDK version this module is built against. If empty, the module is not
334 // build against the VNDK.
335 VndkVersion string `blueprint:"mutated"`
336
337 // Suffix for the name of Android.mk entries generated by this module
338 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800339
340 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
341 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900342 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900343
Yifan Hong39143a92020-10-26 12:43:12 -0700344 // Make this module available when building for ramdisk.
345 // On device without a dedicated recovery partition, the module is only
346 // available after switching root into
347 // /first_stage_ramdisk. To expose the module before switching root, install
348 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800349 Ramdisk_available *bool
350
Yifan Hong39143a92020-10-26 12:43:12 -0700351 // Make this module available when building for vendor ramdisk.
352 // On device without a dedicated recovery partition, the module is only
353 // available after switching root into
354 // /first_stage_ramdisk. To expose the module before switching root, install
355 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700356 Vendor_ramdisk_available *bool
357
Jiyong Parkf9332f12018-02-01 00:54:12 +0900358 // Make this module available when building for recovery
359 Recovery_available *bool
360
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200361 // Used by imageMutator, set by ImageMutatorBegin()
Jihoon Kang47e91842024-06-19 00:51:16 +0000362 VendorVariantNeeded bool `blueprint:"mutated"`
363 ProductVariantNeeded bool `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200364 CoreVariantNeeded bool `blueprint:"mutated"`
365 RamdiskVariantNeeded bool `blueprint:"mutated"`
366 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
367 RecoveryVariantNeeded bool `blueprint:"mutated"`
368
369 // A list of variations for the "image" mutator of the form
370 //<image name> '.' <version char>, for example, 'vendor.S'
371 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900372
373 // Allows this module to use non-APEX version of libraries. Useful
374 // for building binaries that are started before APEXes are activated.
375 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900376
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000377 // Allows this module to be included in CMake release snapshots to be built outside of Android
378 // build system and source tree.
379 Cmake_snapshot_supported *bool
380
Colin Cross1bc94122021-10-28 13:25:54 -0700381 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000382
383 // Set by factories of module types that can only be referenced from variants compiled against
384 // the SDK.
385 AlwaysSdk bool `blueprint:"mutated"`
386
387 // Variant is an SDK variant created by sdkMutator
388 IsSdkVariant bool `blueprint:"mutated"`
389 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
390 // variant to have a ".sdk" suffix.
391 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700392
Jiyong Park46a512f2020-12-04 18:02:13 +0900393 // List of APEXes that this module has private access to for testing purpose. The module
394 // can depend on libraries that are not exported by the APEXes and use private symbols
395 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000396 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800397
398 Target struct {
399 Platform struct {
400 // List of modules required by the core variant.
401 Required []string `android:"arch_variant"`
402
403 // List of modules not required by the core variant.
404 Exclude_required []string `android:"arch_variant"`
405 } `android:"arch_variant"`
406
407 Recovery struct {
408 // List of modules required by the recovery variant.
409 Required []string `android:"arch_variant"`
410
411 // List of modules not required by the recovery variant.
412 Exclude_required []string `android:"arch_variant"`
413 } `android:"arch_variant"`
414 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700415}
416
417type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900418 // whether this module should be allowed to be directly depended by other
419 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900420 // If set to true, two variants will be built separately, one like
421 // normal, and the other limited to the set of libraries and headers
422 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700423 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900424 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700425 // so it shouldn't have any unversioned runtime dependencies, or
426 // make assumptions about the system that may not be true in the
427 // future.
428 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900429 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900430 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900431 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900432 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900433 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700434 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
435 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900436
Justin Yunebcf0c52021-01-08 18:00:19 +0900437 // This is the same as the "vendor_available" except that the install path
438 // of the vendor variant is /odm or /vendor/odm.
439 // By replacing "vendor_available: true" with "odm_available: true", the
440 // module will install its vendor variant to the /odm partition or /vendor/odm.
441 // As the modules with "odm_available: true" still create the vendor variants,
442 // they can link to the other vendor modules as the vendor_available modules do.
443 // Also, the vendor modules can link to odm_available modules.
444 //
445 // It may not be used for VNDK modules.
446 Odm_available *bool
447
Justin Yun63e9ec72020-10-29 16:49:43 +0900448 // whether this module should be allowed to be directly depended by other
449 // modules with `product_specific: true` or `product_available: true`.
450 // If set to true, an additional product variant will be built separately
451 // that is limited to the set of libraries and headers that are exposed to
452 // /product modules.
453 //
454 // The product variant may be used with a different (newer) /system,
455 // so it shouldn't have any unversioned runtime dependencies, or
456 // make assumptions about the system that may not be true in the
457 // future.
458 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900459 // If set to false, this module becomes inaccessible from /product modules.
460 //
461 // Different from the 'vendor_available' property, the modules with
462 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
463 // library without 'product_available' may not be depended on by any other
464 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900465 //
466 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
467 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
468 Product_available *bool
469
Jiyong Park5fb8c102018-04-09 12:03:06 +0900470 // whether this module is capable of being loaded with other instance
471 // (possibly an older version) of the same module in the same process.
472 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
473 // can be double loaded in a vendor process if the library is also a
474 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
475 // explicitly marked as `double_loadable: true` by the owner, or the dependency
476 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
477 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800478
479 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
480 IsLLNDK bool `blueprint:"mutated"`
481
Colin Cross5271fea2021-04-27 13:06:04 -0700482 // IsVendorPublicLibrary is set for the core and product variants of a library that has
483 // vendor_public_library stubs.
484 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800485}
486
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500487// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
488// to understanding details about the type of the current module.
489// For example, one might call these functions to determine whether the current module is a static
490// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800491type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800492 static() bool
493 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700494 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800495 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900496 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900497 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900498 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700499 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900500 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700501 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800502 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900503 minSdkVersion() string
504 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700505 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700506 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800507 IsLlndk() bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800508 isImplementationForLLNDKPublic() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700509 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900510 inProduct() bool
511 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800512 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700513 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900514 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900515 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700516 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700517 baseModuleName() string
Colin Cross3513fb12024-01-24 14:44:47 -0800518 isAfdoCompile(ctx ModuleContext) bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000519 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800520 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900521 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800522 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800523 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800524 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700525 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700526 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900527 bootstrap() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700528 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700529 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800530 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800531 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800532 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800533 notInPlatform() bool
Yi Kong5786f5c2024-05-28 02:22:34 +0900534 optimizeForSize() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800535}
536
537type SharedFlags struct {
538 numSharedFlags int
539 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800540}
541
542type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700543 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800544 ModuleContextIntf
545}
546
547type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700548 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800549 ModuleContextIntf
550}
551
Colin Cross37047f12016-12-13 17:06:13 -0800552type DepsContext interface {
553 android.BottomUpMutatorContext
554 ModuleContextIntf
555}
556
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500557// feature represents additional (optional) steps to building cc-related modules, such as invocation
558// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800559type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800560 flags(ctx ModuleContext, flags Flags) Flags
561 props() []interface{}
562}
563
Joe Onorato37f900c2023-07-18 16:58:16 -0700564// Information returned from Generator about the source code it's generating
565type GeneratedSource struct {
566 IncludeDirs android.Paths
567 Sources android.Paths
568 Headers android.Paths
569 ReexportedDirs android.Paths
570}
571
572// generator allows injection of generated code
573type Generator interface {
574 GeneratorProps() []interface{}
575 GeneratorInit(ctx BaseModuleContext)
576 GeneratorDeps(ctx DepsContext, deps Deps) Deps
577 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
578 GeneratorSources(ctx ModuleContext) GeneratedSource
579 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
580}
581
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500582// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500583// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800584type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700585 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800586 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800587 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700588 compilerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000589 baseCompilerProps() BaseCompilerProperties
Colin Cross42742b82016-08-01 13:20:05 -0700590
Colin Cross76fada02016-07-27 10:31:13 -0700591 appendCflags([]string)
592 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700593 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800594}
595
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500596// linker is the interface for a linker decorator object. Individual module types can provide
597// their own implementation for this decorator, and thus specify custom logic regarding build
598// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800599type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700600 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800601 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700602 linkerFlags(ctx ModuleContext, flags Flags) Flags
603 linkerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000604 baseLinkerProps() BaseLinkerProperties
Ivan Lozanobd721262018-11-27 14:33:03 -0800605 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700606
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700607 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700608 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900609 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800610 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700611
612 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900613 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000614
615 // Get the deps that have been explicitly specified in the properties.
Cole Fauste8a87832024-09-11 11:35:46 -0700616 linkerSpecifiedDeps(ctx android.ConfigurableEvaluatorContext, module *Module, specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800617
618 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000619}
620
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500621// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000622type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500623 sharedLibs []string
624 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
625 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700626 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800627}
628
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500629// installer is the interface for an installer helper object. This helper is responsible for
630// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800631type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700632 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700633 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000634 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800635 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700636 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700637 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900638 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000639 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900640 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800641}
642
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800643type xref interface {
644 XrefCcFiles() android.Paths
645}
646
Inseob Kima1888ce2022-10-04 14:42:02 +0900647type overridable interface {
648 overriddenModules() []string
649}
650
Colin Cross6e511a92020-07-27 21:26:48 -0700651type libraryDependencyKind int
652
653const (
654 headerLibraryDependency = iota
655 sharedLibraryDependency
656 staticLibraryDependency
Ivan Lozano0a468a42024-05-13 21:03:34 -0400657 rlibLibraryDependency
Colin Cross6e511a92020-07-27 21:26:48 -0700658)
659
660func (k libraryDependencyKind) String() string {
661 switch k {
662 case headerLibraryDependency:
663 return "headerLibraryDependency"
664 case sharedLibraryDependency:
665 return "sharedLibraryDependency"
666 case staticLibraryDependency:
667 return "staticLibraryDependency"
Ivan Lozano0a468a42024-05-13 21:03:34 -0400668 case rlibLibraryDependency:
669 return "rlibLibraryDependency"
Colin Cross6e511a92020-07-27 21:26:48 -0700670 default:
671 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
672 }
673}
674
675type libraryDependencyOrder int
676
677const (
678 earlyLibraryDependency = -1
679 normalLibraryDependency = 0
680 lateLibraryDependency = 1
681)
682
683func (o libraryDependencyOrder) String() string {
684 switch o {
685 case earlyLibraryDependency:
686 return "earlyLibraryDependency"
687 case normalLibraryDependency:
688 return "normalLibraryDependency"
689 case lateLibraryDependency:
690 return "lateLibraryDependency"
691 default:
692 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
693 }
694}
695
696// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
697// tags that have a set of predefined tag objects that are reused for each dependency, a
698// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
699// That means that comparing a libraryDependencyTag for equality will only be equal if all
700// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
701// then check individual metadata fields instead.
702type libraryDependencyTag struct {
703 blueprint.BaseDependencyTag
704
705 // These are exported so that fmt.Printf("%#v") can call their String methods.
706 Kind libraryDependencyKind
707 Order libraryDependencyOrder
708
709 wholeStatic bool
710
711 reexportFlags bool
712 explicitlyVersioned bool
713 dataLib bool
714 ndk bool
715
716 staticUnwinder bool
717
718 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900719
Cindy Zhou18417cb2020-12-10 07:12:38 -0800720 // Whether or not this dependency should skip the apex dependency check
721 skipApexAllowedDependenciesCheck bool
722
Jiyong Parke3867542020-12-03 17:28:25 +0900723 // Whether or not this dependency has to be followed for the apex variants
724 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900725 // Whether or not this dependency has to be followed for the non-apex variants
726 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000727
728 // If true, don't automatically export symbols from the static library into a shared library.
729 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700730}
731
732// header returns true if the libraryDependencyTag is tagging a header lib dependency.
733func (d libraryDependencyTag) header() bool {
734 return d.Kind == headerLibraryDependency
735}
736
737// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
738func (d libraryDependencyTag) shared() bool {
739 return d.Kind == sharedLibraryDependency
740}
741
742// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
743func (d libraryDependencyTag) static() bool {
744 return d.Kind == staticLibraryDependency
745}
746
Colin Cross65cb3142021-12-10 23:05:02 +0000747func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
748 if d.shared() {
749 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
750 }
751 return nil
752}
753
754var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
755
Colin Crosse9fe2942020-11-10 18:12:15 -0800756// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
757// binaries or other shared libraries are installed as dependencies.
758func (d libraryDependencyTag) InstallDepNeeded() bool {
759 return d.shared()
760}
761
762var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
763
Yu Liu67a28422024-03-05 00:36:31 +0000764func (d libraryDependencyTag) PropagateAconfigValidation() bool {
765 return d.static()
766}
767
768var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
769
Colin Crosse9fe2942020-11-10 18:12:15 -0800770// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700771// libraryDependencyTag. Each tag object is created globally and reused for multiple
772// dependencies (although since the object contains no references, assigning a tag to a
773// variable and modifying it will not modify the original). Users can compare the tag
774// returned by ctx.OtherModuleDependencyTag against the global original
775type dependencyTag struct {
776 blueprint.BaseDependencyTag
777 name string
778}
779
Colin Crosse9fe2942020-11-10 18:12:15 -0800780// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
781// libraryDependencyTag, but where the dependency needs to be installed when the parent is
782// installed.
783type installDependencyTag struct {
784 blueprint.BaseDependencyTag
785 android.InstallAlwaysNeededDependencyTag
786 name string
787}
788
Colin Crossc99deeb2016-04-11 15:06:20 -0700789var (
Colin Cross6e511a92020-07-27 21:26:48 -0700790 genSourceDepTag = dependencyTag{name: "gen source"}
791 genHeaderDepTag = dependencyTag{name: "gen header"}
792 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
793 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900794 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700795 reuseObjTag = dependencyTag{name: "reuse objects"}
796 staticVariantTag = dependencyTag{name: "static variant"}
797 vndkExtDepTag = dependencyTag{name: "vndk extends"}
798 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700799 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800800 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700801 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000802 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500803 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400804 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800805 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700806)
807
Roland Levillainf89cd092019-07-29 16:22:59 +0100808func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700809 ccLibDepTag, ok := depTag.(libraryDependencyTag)
810 return ok && ccLibDepTag.shared()
811}
812
813func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
814 ccLibDepTag, ok := depTag.(libraryDependencyTag)
815 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100816}
817
Zach Johnson3df4e632020-11-06 11:56:27 -0800818func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
819 ccLibDepTag, ok := depTag.(libraryDependencyTag)
820 return ok && ccLibDepTag.header()
821}
822
Roland Levillainf89cd092019-07-29 16:22:59 +0100823func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800824 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100825}
826
Colin Crossca860ac2016-01-04 14:34:37 -0800827// Module contains the properties and members used by all C/C++ module types, and implements
828// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500829// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
830// interface.
831//
832// To define a C/C++ related module, construct a new Module object and point its delegates to
833// type-specific structs. These delegates will be invoked to register module-specific build
834// statements which may be unique to the module type. For example, module.compiler.compile() should
835// be defined so as to register build statements which are responsible for compiling the module.
836//
837// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
838// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
839// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
840// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800841type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700842 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700843
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700844 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700845 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700846 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700847
Colin Crossca860ac2016-01-04 14:34:37 -0800848 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000849 hod android.HostOrDeviceSupported
850 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000851 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700852
Paul Duffina0843f62019-12-13 19:50:38 +0000853 // Allowable SdkMemberTypes of this module type.
854 sdkMemberTypes []android.SdkMemberType
855
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500856 // decorator delegates, initialize before calling Init
857 // these may contain module-specific implementations, and effectively allow for custom
858 // type-specific logic. These members may reference different objects or the same object.
859 // Functions of these decorators will be invoked to initialize and register type-specific
860 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800861 generators []Generator
862 compiler compiler
863 linker linker
864 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500865
Spandan Dase12d2522023-09-12 21:42:31 +0000866 features []feature
867 stl *stl
868 sanitize *sanitize
869 coverage *coverage
870 fuzzer *fuzzer
871 sabi *sabi
Spandan Dase12d2522023-09-12 21:42:31 +0000872 lto *lto
873 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000874 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800875
Colin Cross31076b32020-10-23 17:22:06 -0700876 library libraryInterface
877
Colin Cross635c3b02016-05-18 15:37:25 -0700878 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800879
Colin Crossb98c8b02016-07-29 13:44:28 -0700880 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700881
882 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800883
884 // Flags used to compile this module
885 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700886
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800887 // Shared flags among build rules of this module
888 sharedFlags SharedFlags
889
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800890 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700891 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900892
893 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800894 // Kythe (source file indexer) paths for this compilation module
895 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700896 // Object .o file output paths for this compilation module
897 objFiles android.Paths
898 // Tidy .tidy file output paths for this compilation module
899 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900900
901 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700902 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700903
904 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800905
Inseob Kim37e0bb02024-04-29 15:54:44 +0900906 logtagsPaths android.Paths
Ivan Lozanofd47b1a2024-05-17 14:13:41 -0400907
908 WholeRustStaticlib bool
Cole Faust96a692b2024-08-08 14:47:51 -0700909
910 hasAidl bool
911 hasLex bool
912 hasProto bool
913 hasRenderscript bool
914 hasSysprop bool
915 hasWinMsg bool
916 hasYacc bool
Colin Crossc472d572015-03-17 15:06:21 -0700917}
918
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200919func (c *Module) AddJSONData(d *map[string]interface{}) {
920 c.AndroidModuleBase().AddJSONData(d)
921 (*d)["Cc"] = map[string]interface{}{
922 "SdkVersion": c.SdkVersion(),
923 "MinSdkVersion": c.MinSdkVersion(),
924 "VndkVersion": c.VndkVersion(),
925 "ProductSpecific": c.ProductSpecific(),
926 "SocSpecific": c.SocSpecific(),
927 "DeviceSpecific": c.DeviceSpecific(),
928 "InProduct": c.InProduct(),
929 "InVendor": c.InVendor(),
930 "InRamdisk": c.InRamdisk(),
931 "InVendorRamdisk": c.InVendorRamdisk(),
932 "InRecovery": c.InRecovery(),
933 "VendorAvailable": c.VendorAvailable(),
934 "ProductAvailable": c.ProductAvailable(),
935 "RamdiskAvailable": c.RamdiskAvailable(),
936 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
937 "RecoveryAvailable": c.RecoveryAvailable(),
938 "OdmAvailable": c.OdmAvailable(),
939 "InstallInData": c.InstallInData(),
940 "InstallInRamdisk": c.InstallInRamdisk(),
941 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
942 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
943 "InstallInRecovery": c.InstallInRecovery(),
944 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200945 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200946 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
947 "ApexSdkVersion": c.apexSdkVersion,
948 "TestFor": c.TestFor(),
Cole Faust96a692b2024-08-08 14:47:51 -0700949 "AidlSrcs": c.hasAidl,
950 "LexSrcs": c.hasLex,
951 "ProtoSrcs": c.hasProto,
952 "RenderscriptSrcs": c.hasRenderscript,
953 "SyspropSrcs": c.hasSysprop,
954 "WinMsgSrcs": c.hasWinMsg,
955 "YaccSrsc": c.hasYacc,
956 "OnlyCSrcs": !(c.hasAidl || c.hasLex || c.hasProto || c.hasRenderscript || c.hasSysprop || c.hasWinMsg || c.hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900957 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200958 }
959}
960
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500961func (c *Module) SetPreventInstall() {
962 c.Properties.PreventInstall = true
963}
964
965func (c *Module) SetHideFromMake() {
966 c.Properties.HideFromMake = true
967}
968
Ivan Lozanod7586b62021-04-01 09:49:36 -0400969func (c *Module) HiddenFromMake() bool {
970 return c.Properties.HideFromMake
971}
972
Cole Fauste8a87832024-09-11 11:35:46 -0700973func (c *Module) RequiredModuleNames(ctx android.ConfigurableEvaluatorContext) []string {
Cole Faust43ddd082024-06-17 12:32:40 -0700974 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800975 if c.ImageVariation().Variation == android.CoreVariation {
976 required = append(required, c.Properties.Target.Platform.Required...)
977 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
978 } else if c.InRecovery() {
979 required = append(required, c.Properties.Target.Recovery.Required...)
980 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
981 }
982 return android.FirstUniqueStrings(required)
983}
984
Ivan Lozano52767be2019-10-18 14:49:46 -0700985func (c *Module) Toc() android.OptionalPath {
986 if c.linker != nil {
987 if library, ok := c.linker.(libraryInterface); ok {
988 return library.toc()
989 }
990 }
991 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
992}
993
994func (c *Module) ApiLevel() string {
995 if c.linker != nil {
996 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700997 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700998 }
999 }
1000 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1001}
1002
1003func (c *Module) Static() bool {
1004 if c.linker != nil {
1005 if library, ok := c.linker.(libraryInterface); ok {
1006 return library.static()
1007 }
1008 }
1009 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1010}
1011
1012func (c *Module) Shared() bool {
1013 if c.linker != nil {
1014 if library, ok := c.linker.(libraryInterface); ok {
1015 return library.shared()
1016 }
1017 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001018
Ivan Lozano52767be2019-10-18 14:49:46 -07001019 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1020}
1021
1022func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001023 if c.stl != nil {
1024 return c.stl.Properties.SelectedStl
1025 }
1026 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001027}
1028
Ivan Lozano52767be2019-10-18 14:49:46 -07001029func (c *Module) StubDecorator() bool {
1030 if _, ok := c.linker.(*stubDecorator); ok {
1031 return true
1032 }
1033 return false
1034}
1035
Yi Kong5786f5c2024-05-28 02:22:34 +09001036func (c *Module) OptimizeForSize() bool {
1037 return Bool(c.Properties.Optimize_for_size)
1038}
1039
Ivan Lozano52767be2019-10-18 14:49:46 -07001040func (c *Module) SdkVersion() string {
1041 return String(c.Properties.Sdk_version)
1042}
1043
Artur Satayev480e25b2020-04-27 18:53:18 +01001044func (c *Module) MinSdkVersion() string {
1045 return String(c.Properties.Min_sdk_version)
1046}
1047
Jiyong Park5df7bd32021-08-25 16:18:46 +09001048func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001049 if linker, ok := c.linker.(*objectLinker); ok {
1050 return linker.isCrt()
1051 }
1052 return false
1053}
1054
Jiyong Park5df7bd32021-08-25 16:18:46 +09001055func (c *Module) SplitPerApiLevel() bool {
1056 return c.canUseSdk() && c.isCrt()
1057}
1058
Colin Crossc511bc52020-04-07 16:50:32 +00001059func (c *Module) AlwaysSdk() bool {
1060 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1061}
1062
Ivan Lozano183a3212019-10-18 14:18:45 -07001063func (c *Module) CcLibrary() bool {
1064 if c.linker != nil {
1065 if _, ok := c.linker.(*libraryDecorator); ok {
1066 return true
1067 }
Colin Crossd48fe732020-09-23 20:37:24 -07001068 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1069 return true
1070 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001071 }
1072 return false
1073}
1074
1075func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001076 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001077 return true
1078 }
1079 return false
1080}
1081
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001082func (c *Module) RlibStd() bool {
1083 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1084}
1085
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001086func (c *Module) RustLibraryInterface() bool {
1087 return false
1088}
1089
Ivan Lozano0a468a42024-05-13 21:03:34 -04001090func (c *Module) CrateName() string {
1091 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1092}
1093
1094func (c *Module) ExportedCrateLinkDirs() []string {
1095 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1096}
1097
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001098func (c *Module) IsFuzzModule() bool {
1099 if _, ok := c.compiler.(*fuzzBinary); ok {
1100 return true
1101 }
1102 return false
1103}
1104
1105func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1106 return c.FuzzModule
1107}
1108
1109func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1110 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1111 return fuzzer.fuzzPackagedModule
1112 }
1113 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1114}
1115
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001116func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001117 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1118 return fuzzer.sharedLibraries
1119 }
1120 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1121}
1122
Ivan Lozano2b262972019-11-21 12:30:50 -08001123func (c *Module) NonCcVariants() bool {
1124 return false
1125}
1126
Ivan Lozano183a3212019-10-18 14:18:45 -07001127func (c *Module) SetStatic() {
1128 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001129 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001130 library.setStatic()
1131 return
1132 }
1133 }
1134 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1135}
1136
1137func (c *Module) SetShared() {
1138 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001139 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001140 library.setShared()
1141 return
1142 }
1143 }
1144 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1145}
1146
1147func (c *Module) BuildStaticVariant() bool {
1148 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001149 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001150 return library.buildStatic()
1151 }
1152 }
1153 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1154}
1155
1156func (c *Module) BuildSharedVariant() bool {
1157 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001158 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001159 return library.buildShared()
1160 }
1161 }
1162 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1163}
1164
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04001165func (c *Module) BuildRlibVariant() bool {
1166 // cc modules can never build rlib variants
1167 return false
1168}
1169
1170func (c *Module) IsRustFFI() bool {
1171 // cc modules are not Rust modules
1172 return false
1173}
1174
Ivan Lozano183a3212019-10-18 14:18:45 -07001175func (c *Module) Module() android.Module {
1176 return c
1177}
1178
Jiyong Parkc20eee32018-09-05 22:36:17 +09001179func (c *Module) OutputFile() android.OptionalPath {
1180 return c.outputFile
1181}
1182
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001183func (c *Module) CoverageFiles() android.Paths {
1184 if c.linker != nil {
1185 if library, ok := c.linker.(libraryInterface); ok {
1186 return library.objs().coverageFiles
1187 }
1188 }
1189 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1190}
1191
Ivan Lozano183a3212019-10-18 14:18:45 -07001192var _ LinkableInterface = (*Module)(nil)
1193
Jiyong Park719b4462019-01-13 00:39:51 +09001194func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001195 if c.linker != nil {
1196 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001197 }
1198 return nil
1199}
1200
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001201func (c *Module) CoverageOutputFile() android.OptionalPath {
1202 if c.linker != nil {
1203 return c.linker.coverageOutputFilePath()
1204 }
1205 return android.OptionalPath{}
1206}
1207
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001208func (c *Module) RelativeInstallPath() string {
1209 if c.installer != nil {
1210 return c.installer.relativeInstallPath()
1211 }
1212 return ""
1213}
1214
Jooyung Han344d5432019-08-23 11:17:39 +09001215func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001216 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001217}
1218
Colin Cross36242852017-06-23 15:06:31 -07001219func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001220 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001221 for _, generator := range c.generators {
1222 c.AddProperties(generator.GeneratorProps()...)
1223 }
Colin Crossca860ac2016-01-04 14:34:37 -08001224 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001225 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001226 }
1227 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001228 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001229 }
1230 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001231 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001232 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001233 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001234 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001235 }
Colin Cross16b23492016-01-06 14:41:07 -08001236 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001237 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001238 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001239 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001240 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001241 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001242 if c.fuzzer != nil {
1243 c.AddProperties(c.fuzzer.props()...)
1244 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001245 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001246 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001247 }
Stephen Craneba090d12017-05-09 15:44:35 -07001248 if c.lto != nil {
1249 c.AddProperties(c.lto.props()...)
1250 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001251 if c.afdo != nil {
1252 c.AddProperties(c.afdo.props()...)
1253 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001254 if c.orderfile != nil {
1255 c.AddProperties(c.orderfile.props()...)
1256 }
Colin Crossca860ac2016-01-04 14:34:37 -08001257 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001258 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001259 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001260 // Allow test-only on libraries that are not cc_test_library
1261 if c.library != nil && !c.testLibrary() {
1262 c.AddProperties(&c.sourceProperties)
1263 }
Colin Crossc472d572015-03-17 15:06:21 -07001264
Colin Cross36242852017-06-23 15:06:31 -07001265 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001266 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001267 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001268
Colin Cross36242852017-06-23 15:06:31 -07001269 return c
Colin Crossc472d572015-03-17 15:06:21 -07001270}
1271
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001272// UseVndk() returns true if this module is built against VNDK.
1273// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001274func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001275 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001276}
1277
Colin Crossc511bc52020-04-07 16:50:32 +00001278func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001279 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001280 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001281}
1282
1283func (c *Module) UseSdk() bool {
1284 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001285 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001286 }
1287 return false
1288}
1289
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001290func (c *Module) isCoverageVariant() bool {
1291 return c.coverage.Properties.IsCoverageVariant
1292}
1293
Colin Cross95f1ca02020-10-29 20:47:22 -07001294func (c *Module) IsNdk(config android.Config) bool {
1295 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001296}
1297
Colin Cross127bb8b2020-12-16 16:46:01 -08001298func (c *Module) IsLlndk() bool {
1299 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001300}
1301
Colin Cross1f3f1302021-04-26 18:37:44 -07001302func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001303 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001304 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001305}
1306
Colin Cross5271fea2021-04-27 13:06:04 -07001307func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1308 lib := moduleLibraryInterface(m)
1309 return lib != nil && (lib.hasVendorPublicLibrary())
1310}
1311
1312// IsVendorPublicLibrary returns true for vendor public libraries.
1313func (c *Module) IsVendorPublicLibrary() bool {
1314 return c.VendorProperties.IsVendorPublicLibrary
1315}
1316
Ivan Lozanof1868af2022-04-12 13:08:36 -04001317func (c *Module) IsVndkPrebuiltLibrary() bool {
1318 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1319 return true
1320 }
1321 return false
1322}
1323
1324func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1325 return c.Properties.SdkAndPlatformVariantVisibleToMake
1326}
1327
Ivan Lozanod7586b62021-04-01 09:49:36 -04001328func (c *Module) HasLlndkStubs() bool {
1329 lib := moduleLibraryInterface(c)
1330 return lib != nil && lib.hasLLNDKStubs()
1331}
1332
1333func (c *Module) StubsVersion() string {
1334 if lib, ok := c.linker.(versionedInterface); ok {
1335 return lib.stubsVersion()
1336 }
1337 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1338}
1339
Colin Cross127bb8b2020-12-16 16:46:01 -08001340// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1341// and does not set llndk.vendor_available: false.
1342func (c *Module) isImplementationForLLNDKPublic() bool {
1343 library, _ := c.library.(*libraryDecorator)
1344 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001345 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001346}
1347
Colin Cross3513fb12024-01-24 14:44:47 -08001348func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001349 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001350 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001351 }
1352 return false
1353}
1354
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001355func (c *Module) isOrderfileCompile() bool {
1356 if orderfile := c.orderfile; orderfile != nil {
1357 return orderfile.Properties.OrderfileLoad
1358 }
1359 return false
1360}
1361
Yi Kongc702ebd2022-08-19 16:02:45 +08001362func (c *Module) isCfi() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001363 return c.sanitize.isSanitizerEnabled(cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001364}
1365
Yi Konged79fa32023-06-04 17:15:42 +09001366func (c *Module) isFuzzer() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001367 return c.sanitize.isSanitizerEnabled(Fuzzer)
Yi Konged79fa32023-06-04 17:15:42 +09001368}
1369
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001370func (c *Module) isNDKStubLibrary() bool {
1371 if _, ok := c.compiler.(*stubDecorator); ok {
1372 return true
1373 }
1374 return false
1375}
1376
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001377func (c *Module) SubName() string {
1378 return c.Properties.SubName
1379}
1380
Jiyong Park25fc6a92018-11-18 18:02:45 +09001381func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001382 if lib := c.library; lib != nil {
1383 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001384 }
1385 return false
1386}
1387
1388func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001389 if lib := c.library; lib != nil {
1390 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001391 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001392 return false
1393}
1394
Alan Stokes73feba32022-11-14 12:21:24 +00001395func (c *Module) IsStubsImplementationRequired() bool {
1396 if lib := c.library; lib != nil {
1397 return lib.isStubsImplementationRequired()
1398 }
1399 return false
1400}
1401
Colin Cross0477b422020-10-13 18:43:54 -07001402// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1403// the implementation. If it is an implementation library it returns its own name.
1404func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1405 name := ctx.OtherModuleName(c)
1406 if versioned, ok := c.linker.(versionedInterface); ok {
1407 name = versioned.implementationModuleName(name)
1408 }
1409 return name
1410}
1411
Martin Stjernholm2856c662020-12-02 15:03:42 +00001412// Similar to ImplementationModuleName, but uses the Make variant of the module
1413// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1414// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1415// under the premise that the prebuilt module overrides its source counterpart
1416// if it is exposed to Make).
1417func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1418 name := c.BaseModuleName()
1419 if versioned, ok := c.linker.(versionedInterface); ok {
1420 name = versioned.implementationModuleName(name)
1421 }
1422 return name
1423}
1424
Jiyong Park7d55b612021-06-11 17:22:09 +09001425func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001426 return Bool(c.Properties.Bootstrap)
1427}
1428
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001429func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001430 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1431 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1432 return false
1433 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001434 return c.linker != nil && c.linker.nativeCoverage()
1435}
1436
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001437func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001438 if p, ok := c.linker.(SnapshotInterface); ok {
1439 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001440 }
1441 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001442}
1443
Jiyong Parkf1194352019-02-25 11:05:47 +09001444func isBionic(name string) bool {
1445 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001446 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001447 return true
1448 }
1449 return false
1450}
1451
Martin Stjernholm279de572019-09-10 23:18:20 +01001452func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001453 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001454 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001455 }
1456 return isBionic(name)
1457}
1458
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001459func (c *Module) XrefCcFiles() android.Paths {
1460 return c.kytheFiles
1461}
1462
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001463func (c *Module) isCfiAssemblySupportEnabled() bool {
1464 return c.sanitize != nil &&
1465 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1466}
1467
Inseob Kim800d1142021-06-14 12:03:51 +09001468func (c *Module) InstallInRoot() bool {
1469 return c.installer != nil && c.installer.installInRoot()
1470}
1471
Colin Crossca860ac2016-01-04 14:34:37 -08001472type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001473 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001474 moduleContextImpl
1475}
1476
Colin Cross37047f12016-12-13 17:06:13 -08001477type depsContext struct {
1478 android.BottomUpMutatorContext
1479 moduleContextImpl
1480}
1481
Colin Crossca860ac2016-01-04 14:34:37 -08001482type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001483 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001484 moduleContextImpl
1485}
1486
1487type moduleContextImpl struct {
1488 mod *Module
1489 ctx BaseModuleContext
1490}
1491
Colin Crossb98c8b02016-07-29 13:44:28 -07001492func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001493 return ctx.mod.toolchain(ctx.ctx)
1494}
1495
1496func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001497 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001498}
1499
1500func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001501 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001502}
1503
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001504func (ctx *moduleContextImpl) testBinary() bool {
1505 return ctx.mod.testBinary()
1506}
1507
Yi Kong56fc1b62022-09-06 16:24:00 +08001508func (ctx *moduleContextImpl) testLibrary() bool {
1509 return ctx.mod.testLibrary()
1510}
1511
Jiyong Park1d1119f2019-07-29 21:27:18 +09001512func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001513 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001514}
1515
Inseob Kim7f283f42020-06-01 21:53:49 +09001516func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001517 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001518}
1519
Inseob Kim1042d292020-06-01 23:23:05 +09001520func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001521 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001522}
1523
Yi Kong5786f5c2024-05-28 02:22:34 +09001524func (ctx *moduleContextImpl) optimizeForSize() bool {
1525 return ctx.mod.OptimizeForSize()
1526}
1527
Jooyung Hanccce2f22020-03-07 03:45:53 +09001528func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001529 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001530}
1531
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001532func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001533 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001534}
1535
1536func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001537 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001538 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001539 }
1540 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001541}
1542
Jiyong Parkb35a8192020-08-10 15:59:36 +09001543func (ctx *moduleContextImpl) minSdkVersion() string {
1544 ver := ctx.mod.MinSdkVersion()
1545 if ver == "apex_inherit" && !ctx.isForPlatform() {
1546 ver = ctx.apexSdkVersion().String()
1547 }
1548 if ver == "apex_inherit" || ver == "" {
1549 ver = ctx.sdkVersion()
1550 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001551
1552 if ctx.ctx.Device() {
1553 config := ctx.ctx.Config()
Kiyoung Kim8f05c542024-05-22 16:50:34 +09001554 if ctx.inVendor() {
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001555 // If building for vendor with final API, then use the latest _stable_ API as "current".
1556 if config.VendorApiLevelFrozen() && (ver == "" || ver == "current") {
1557 ver = config.PlatformSdkVersion().String()
1558 }
1559 }
1560 }
1561
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001562 // For crt objects, the meaning of min_sdk_version is very different from other types of
1563 // module. For them, min_sdk_version defines the oldest version that the build system will
1564 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1565 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1566 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001567 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1568 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1569 // support such an old version. The version is set to the later version in case when the
1570 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1571 // it's for an APEX.
1572 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1573 if ctx.isForPlatform() {
1574 ver = strconv.Itoa(android.FutureApiLevelInt)
1575 } else { // for apex
1576 ver = ctx.apexSdkVersion().String()
1577 if ver == "" { // in case when min_sdk_version was not set by the APEX
1578 ver = ctx.sdkVersion()
1579 }
1580 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001581 }
1582
Jiyong Parkb35a8192020-08-10 15:59:36 +09001583 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1584 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1585 minSdkVersionInt, err2 := strconv.Atoi(ver)
1586 if err == nil && err2 == nil {
1587 if sdkVersionInt < minSdkVersionInt {
1588 return strconv.Itoa(sdkVersionInt)
1589 }
1590 }
1591 return ver
1592}
1593
1594func (ctx *moduleContextImpl) isSdkVariant() bool {
1595 return ctx.mod.IsSdkVariant()
1596}
1597
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001598func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001599 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001600}
Justin Yun8effde42017-06-23 19:24:43 +09001601
Kiyoung Kimaa394802024-01-08 12:55:45 +09001602func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1603 return ctx.mod.InVendorOrProduct()
1604}
1605
Colin Cross95f1ca02020-10-29 20:47:22 -07001606func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1607 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001608}
1609
Colin Cross127bb8b2020-12-16 16:46:01 -08001610func (ctx *moduleContextImpl) IsLlndk() bool {
1611 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001612}
1613
Colin Cross127bb8b2020-12-16 16:46:01 -08001614func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1615 return ctx.mod.isImplementationForLLNDKPublic()
1616}
1617
Colin Cross3513fb12024-01-24 14:44:47 -08001618func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1619 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001620}
1621
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001622func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1623 return ctx.mod.isOrderfileCompile()
1624}
1625
Yi Kongc702ebd2022-08-19 16:02:45 +08001626func (ctx *moduleContextImpl) isCfi() bool {
1627 return ctx.mod.isCfi()
1628}
1629
Yi Konged79fa32023-06-04 17:15:42 +09001630func (ctx *moduleContextImpl) isFuzzer() bool {
1631 return ctx.mod.isFuzzer()
1632}
1633
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001634func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1635 return ctx.mod.isNDKStubLibrary()
1636}
1637
Colin Cross5271fea2021-04-27 13:06:04 -07001638func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1639 return ctx.mod.IsVendorPublicLibrary()
1640}
1641
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001642func (ctx *moduleContextImpl) selectedStl() string {
1643 if stl := ctx.mod.stl; stl != nil {
1644 return stl.Properties.SelectedStl
1645 }
1646 return ""
1647}
1648
Ivan Lozanobd721262018-11-27 14:33:03 -08001649func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1650 return ctx.mod.linker.useClangLld(actx)
1651}
1652
Colin Crossce75d2c2016-10-06 16:12:58 -07001653func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001654 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001655}
1656
Logan Chiene274fc92019-12-03 11:18:32 -08001657func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001658 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1659 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001660}
1661
Colin Crosse07f2312020-08-13 11:24:56 -07001662func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001663 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1664 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001665}
1666
Dan Albertc8060532020-07-22 22:32:17 -07001667func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001668 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001669}
1670
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001671func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001672 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001673}
1674
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001675func (ctx *moduleContextImpl) nativeCoverage() bool {
1676 return ctx.mod.nativeCoverage()
1677}
1678
Colin Cross56a83212020-09-15 18:30:11 -07001679func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1680 return ctx.mod.DirectlyInAnyApex()
1681}
1682
Colin Cross95b07f22020-12-16 11:06:50 -08001683func (ctx *moduleContextImpl) isPreventInstall() bool {
1684 return ctx.mod.Properties.PreventInstall
1685}
1686
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001687func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1688 shared := &ctx.mod.sharedFlags
1689 if shared.flagsMap == nil {
1690 shared.numSharedFlags = 0
1691 shared.flagsMap = make(map[string]string)
1692 }
1693 return shared
1694}
1695
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001696func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1697 return ctx.mod.isCfiAssemblySupportEnabled()
1698}
1699
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001700func (ctx *moduleContextImpl) notInPlatform() bool {
1701 return ctx.mod.NotInPlatform()
1702}
1703
Colin Cross635c3b02016-05-18 15:37:25 -07001704func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001705 return &Module{
1706 hod: hod,
1707 multilib: multilib,
1708 }
1709}
1710
Colin Cross635c3b02016-05-18 15:37:25 -07001711func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001712 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001713 module.features = []feature{
1714 &tidyFeature{},
1715 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001716 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001717 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001718 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001719 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001720 module.sabi = &sabi{}
Stephen Craneba090d12017-05-09 15:44:35 -07001721 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001722 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001723 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001724 return module
1725}
1726
Colin Crossce75d2c2016-10-06 16:12:58 -07001727func (c *Module) Prebuilt() *android.Prebuilt {
1728 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1729 return p.prebuilt()
1730 }
1731 return nil
1732}
1733
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001734func (c *Module) IsPrebuilt() bool {
1735 return c.Prebuilt() != nil
1736}
1737
Colin Crossce75d2c2016-10-06 16:12:58 -07001738func (c *Module) Name() string {
1739 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001740 if p, ok := c.linker.(interface {
1741 Name(string) string
1742 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001743 name = p.Name(name)
1744 }
1745 return name
1746}
1747
Alex Light3d673592019-01-18 14:37:31 -08001748func (c *Module) Symlinks() []string {
1749 if p, ok := c.installer.(interface {
1750 symlinkList() []string
1751 }); ok {
1752 return p.symlinkList()
1753 }
1754 return nil
1755}
1756
Chris Parsons216e10a2020-07-09 17:12:52 -04001757func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001758 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001759 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001760 }); ok {
1761 return p.dataPaths()
1762 }
1763 return nil
1764}
1765
Ivan Lozanof1868af2022-04-12 13:08:36 -04001766func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001767 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1768 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001769 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001770 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001771 if c.ProductSpecific() {
1772 // If the module is product specific with 'product_specific: true',
1773 // do not add a name suffix because it is a base module.
1774 return ""
1775 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001776 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001777 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001778 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001779 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001780 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001781 // add version suffix only if the module is using different vndk version than the
1782 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001783 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001784 }
1785 return nameSuffix
1786}
1787
Ivan Lozanof1868af2022-04-12 13:08:36 -04001788func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1789 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001790
1791 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001792 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001793 }
1794
Colin Cross127bb8b2020-12-16 16:46:01 -08001795 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001796 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001797 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1798 // added for product variant only when we have vendor and product variants with core
1799 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001800 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001801 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001802 subName += vendorPublicLibrarySuffix
1803 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001804 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1805 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001806 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001807 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001808 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001809 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001810 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001811 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001812 subName += RecoverySuffix
1813 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1814 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001815 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001816 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001817 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001818 } else if c.IsStubs() && c.IsSdkVariant() {
1819 // Public API surface (NDK)
1820 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1821 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001822 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001823
1824 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001825}
1826
Sam Delmerico75dbca22023-04-20 13:13:25 +00001827func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1828 ctx := &moduleContext{
1829 ModuleContext: actx,
1830 moduleContextImpl: moduleContextImpl{
1831 mod: c,
1832 },
1833 }
1834 ctx.ctx = ctx
1835 return ctx
1836}
1837
Spandan Das20fce2d2023-04-12 17:21:39 +00001838// TODO (b/277651159): Remove this allowlist
1839var (
1840 skipStubLibraryMultipleApexViolation = map[string]bool{
1841 "libclang_rt.asan": true,
1842 "libclang_rt.hwasan": true,
1843 // runtime apex
1844 "libc": true,
1845 "libc_hwasan": true,
1846 "libdl_android": true,
1847 "libm": true,
1848 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001849 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001850 // art apex
Martin Stjernholm75598032024-07-12 18:47:26 +01001851 // TODO(b/234351700): Remove this when com.android.art.debug is gone.
Spandan Das20fce2d2023-04-12 17:21:39 +00001852 "libandroidio": true,
1853 "libdexfile": true,
Martin Stjernholm75598032024-07-12 18:47:26 +01001854 "libdexfiled": true, // com.android.art.debug only
Spandan Das20fce2d2023-04-12 17:21:39 +00001855 "libnativebridge": true,
1856 "libnativehelper": true,
1857 "libnativeloader": true,
1858 "libsigchain": true,
1859 }
1860)
1861
1862// Returns true if a stub library could be installed in multiple apexes
1863func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1864 // If this is not an apex variant, no check necessary
1865 if !c.InAnyApex() {
1866 return false
1867 }
1868 // If this is not a stub library, no check necessary
1869 if !c.HasStubsVariants() {
1870 return false
1871 }
1872 // Skip the allowlist
1873 // Use BaseModuleName so that this matches prebuilts.
1874 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1875 return false
1876 }
1877
1878 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1879 // Stub libraries should not have more than one apex_available
1880 if len(aaWithoutTestApexes) > 1 {
1881 return true
1882 }
1883 // Stub libraries should not use the wildcard
1884 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1885 return true
1886 }
1887 // Default: no violation
1888 return false
1889}
1890
Chris Parsons8d6e4332021-02-22 16:13:50 -05001891func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001892 ctx := moduleContextFromAndroidModuleContext(actx, c)
1893
Inseob Kim37e0bb02024-04-29 15:54:44 +09001894 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
1895 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
1896 Logtags: c.logtagsPaths,
1897 })
1898
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001899 // If Test_only is set on a module in bp file, respect the setting, otherwise
1900 // see if is a known test module type.
1901 testOnly := c.testModule || c.testLibrary()
1902 if c.sourceProperties.Test_only != nil {
1903 testOnly = Bool(c.sourceProperties.Test_only)
1904 }
1905 // Keep before any early returns.
1906 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
1907 TestOnly: testOnly,
1908 TopLevelTarget: c.testModule,
1909 })
1910
Ivan Lozanof1868af2022-04-12 13:08:36 -04001911 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08001912 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001913 if !apexInfo.IsForPlatform() {
1914 c.hideApexVariantFromMake = true
1915 }
1916
Chris Parsonseefc9e62021-04-02 17:36:47 -04001917 c.makeLinkType = GetMakeLinkType(actx, c)
1918
Colin Crossf18e1102017-11-16 14:33:08 -08001919 deps := c.depsToPaths(ctx)
1920 if ctx.Failed() {
1921 return
1922 }
1923
Joe Onorato37f900c2023-07-18 16:58:16 -07001924 for _, generator := range c.generators {
1925 gen := generator.GeneratorSources(ctx)
1926 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
1927 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
1928 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
1929 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
1930 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
1931 if len(deps.Objs.objFiles) == 0 {
1932 // If we are reusuing object files (which happens when we're a shared library and we're
1933 // reusing our static variant's object files), then skip adding the actual source files,
1934 // because we already have the object for it.
1935 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
1936 }
1937 }
1938
1939 if ctx.Failed() {
1940 return
1941 }
1942
Spandan Das20fce2d2023-04-12 17:21:39 +00001943 if c.stubLibraryMultipleApexViolation(actx) {
1944 actx.PropertyErrorf("apex_available",
1945 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
1946 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001947 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1948 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001949 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1950 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001951 }
1952
Colin Crossca860ac2016-01-04 14:34:37 -08001953 flags := Flags{
1954 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001955 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001956 }
Joe Onorato37f900c2023-07-18 16:58:16 -07001957 for _, generator := range c.generators {
1958 flags = generator.GeneratorFlags(ctx, flags, deps)
1959 }
Colin Crossca860ac2016-01-04 14:34:37 -08001960 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001961 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001962 }
1963 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001964 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001965 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001966 if c.stl != nil {
1967 flags = c.stl.flags(ctx, flags)
1968 }
Colin Cross16b23492016-01-06 14:41:07 -08001969 if c.sanitize != nil {
1970 flags = c.sanitize.flags(ctx, flags)
1971 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001972 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001973 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001974 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001975 if c.fuzzer != nil {
1976 flags = c.fuzzer.flags(ctx, flags)
1977 }
Stephen Craneba090d12017-05-09 15:44:35 -07001978 if c.lto != nil {
1979 flags = c.lto.flags(ctx, flags)
1980 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001981 if c.afdo != nil {
1982 flags = c.afdo.flags(ctx, flags)
1983 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001984 if c.orderfile != nil {
1985 flags = c.orderfile.flags(ctx, flags)
1986 }
Colin Crossca860ac2016-01-04 14:34:37 -08001987 for _, feature := range c.features {
1988 flags = feature.flags(ctx, flags)
1989 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001990 if ctx.Failed() {
1991 return
1992 }
1993
Colin Cross4af21ed2019-11-04 09:37:55 -08001994 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1995 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1996 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001997
Colin Cross4af21ed2019-11-04 09:37:55 -08001998 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001999
2000 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002001 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002002 }
2003 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002004 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002005 }
2006
Colin Cross3e5e7782022-06-17 22:17:05 +00002007 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2008
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002009 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002010 // We need access to all the flags seen by a source file.
2011 if c.sabi != nil {
2012 flags = c.sabi.flags(ctx, flags)
2013 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002014
Colin Cross4af21ed2019-11-04 09:37:55 -08002015 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002016
Joe Onorato37f900c2023-07-18 16:58:16 -07002017 for _, generator := range c.generators {
2018 generator.GeneratorBuildActions(ctx, flags, deps)
2019 }
2020
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002021 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002022 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002023 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002024 if ctx.Failed() {
2025 return
2026 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002027 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002028 c.objFiles = objs.objFiles
2029 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002030 }
2031
Colin Crossca860ac2016-01-04 14:34:37 -08002032 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002033 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002034 if ctx.Failed() {
2035 return
2036 }
Colin Cross635c3b02016-05-18 15:37:25 -07002037 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002038
Chris Parsons94a0bba2021-06-04 15:03:47 -04002039 c.maybeUnhideFromMake()
Colin Crossce75d2c2016-10-06 16:12:58 -07002040 }
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002041 if c.testModule {
Colin Cross40213022023-12-13 15:19:49 -08002042 android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{})
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002043 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002044
Colin Cross40213022023-12-13 15:19:49 -08002045 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002046
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002047 if Bool(c.Properties.Cmake_snapshot_supported) {
2048 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2049 }
2050
Chris Parsons94a0bba2021-06-04 15:03:47 -04002051 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002052
2053 if c.linker != nil {
2054 moduleInfoJSON := ctx.ModuleInfoJSON()
2055 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2056 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2057 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2058 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2059 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2060
2061 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2062 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2063 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2064 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2065
2066 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2067 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2068 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2069 moduleInfoJSON.SubName += ".cfi"
2070 }
2071 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2072 moduleInfoJSON.SubName += ".hwasan"
2073 }
2074 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2075 moduleInfoJSON.SubName += ".scs"
2076 }
2077 }
2078 moduleInfoJSON.SubName += c.Properties.SubName
2079
2080 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2081 moduleInfoJSON.Uninstallable = true
2082 }
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002083 }
Wei Lia1aa2972024-06-21 13:08:51 -07002084
2085 buildComplianceMetadataInfo(ctx, c, deps)
mrziwangabdb2932024-06-18 12:43:41 -07002086
Cole Faust96a692b2024-08-08 14:47:51 -07002087 if b, ok := c.compiler.(*baseCompiler); ok {
2088 c.hasAidl = b.hasSrcExt(ctx, ".aidl")
2089 c.hasLex = b.hasSrcExt(ctx, ".l") || b.hasSrcExt(ctx, ".ll")
2090 c.hasProto = b.hasSrcExt(ctx, ".proto")
2091 c.hasRenderscript = b.hasSrcExt(ctx, ".rscript") || b.hasSrcExt(ctx, ".fs")
2092 c.hasSysprop = b.hasSrcExt(ctx, ".sysprop")
2093 c.hasWinMsg = b.hasSrcExt(ctx, ".mc")
2094 c.hasYacc = b.hasSrcExt(ctx, ".y") || b.hasSrcExt(ctx, ".yy")
2095 }
2096
mrziwangabdb2932024-06-18 12:43:41 -07002097 c.setOutputFiles(ctx)
2098}
2099
2100func (c *Module) setOutputFiles(ctx ModuleContext) {
2101 if c.outputFile.Valid() {
2102 ctx.SetOutputFiles(android.Paths{c.outputFile.Path()}, "")
2103 } else {
2104 ctx.SetOutputFiles(android.Paths{}, "")
2105 }
2106 if c.linker != nil {
2107 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), "unstripped")
2108 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), "stripped_all")
2109 }
Wei Lia1aa2972024-06-21 13:08:51 -07002110}
2111
2112func buildComplianceMetadataInfo(ctx ModuleContext, c *Module, deps PathDeps) {
2113 // Dump metadata that can not be done in android/compliance-metadata.go
2114 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
2115 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.IS_STATIC_LIB, strconv.FormatBool(ctx.static()))
2116 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.BUILT_FILES, c.outputFile.String())
2117
2118 // Static deps
2119 staticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(false))
2120 staticDepNames := make([]string, 0, len(staticDeps))
2121 for _, dep := range staticDeps {
2122 staticDepNames = append(staticDepNames, dep.Name())
2123 }
2124
2125 staticDepPaths := make([]string, 0, len(deps.StaticLibs))
2126 for _, dep := range deps.StaticLibs {
2127 staticDepPaths = append(staticDepPaths, dep.String())
2128 }
2129 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEPS, android.FirstUniqueStrings(staticDepNames))
2130 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEP_FILES, android.FirstUniqueStrings(staticDepPaths))
2131
2132 // Whole static deps
2133 wholeStaticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(true))
2134 wholeStaticDepNames := make([]string, 0, len(wholeStaticDeps))
2135 for _, dep := range wholeStaticDeps {
2136 wholeStaticDepNames = append(wholeStaticDepNames, dep.Name())
2137 }
2138
2139 wholeStaticDepPaths := make([]string, 0, len(deps.WholeStaticLibs))
2140 for _, dep := range deps.WholeStaticLibs {
2141 wholeStaticDepPaths = append(wholeStaticDepPaths, dep.String())
2142 }
2143 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEPS, android.FirstUniqueStrings(wholeStaticDepNames))
2144 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEP_FILES, android.FirstUniqueStrings(wholeStaticDepPaths))
Chris Parsons94a0bba2021-06-04 15:03:47 -04002145}
2146
2147func (c *Module) maybeUnhideFromMake() {
2148 // If a lib is directly included in any of the APEXes or is not available to the
2149 // platform (which is often the case when the stub is provided as a prebuilt),
2150 // unhide the stubs variant having the latest version gets visible to make. In
2151 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2152 // force anything in the make world to link against the stubs library. (unless it
2153 // is explicitly referenced via .bootstrap suffix or the module is marked with
2154 // 'bootstrap: true').
2155 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002156 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002157 c.IsStubs() && !c.InVendorRamdisk() {
2158 c.Properties.HideFromMake = false // unhide
2159 // Note: this is still non-installable
2160 }
2161}
2162
Colin Cross8ff10582023-12-07 13:10:56 -08002163// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2164// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002165func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002166 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002167 // If the module has been specifically configure to not be installed then
2168 // hide from make as otherwise it will break when running inside make
2169 // as the output path to install will not be specified. Not all uninstallable
2170 // modules can be hidden from make as some are needed for resolving make side
2171 // dependencies.
2172 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002173 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002174 c.SkipInstall()
2175 }
2176
2177 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2178 // to allow using the outputs in a genrule.
2179 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002180 c.installer.install(ctx, c.outputFile.Path())
2181 if ctx.Failed() {
2182 return
Colin Crossca860ac2016-01-04 14:34:37 -08002183 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002184 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002185}
2186
Colin Cross0ea8ba82019-06-06 14:33:29 -07002187func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002188 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002189 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002190 }
Colin Crossca860ac2016-01-04 14:34:37 -08002191 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002192}
2193
Colin Crossca860ac2016-01-04 14:34:37 -08002194func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002195 for _, generator := range c.generators {
2196 generator.GeneratorInit(ctx)
2197 }
Colin Crossca860ac2016-01-04 14:34:37 -08002198 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002199 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002200 }
Colin Crossca860ac2016-01-04 14:34:37 -08002201 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002202 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002203 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002204 if c.stl != nil {
2205 c.stl.begin(ctx)
2206 }
Colin Cross16b23492016-01-06 14:41:07 -08002207 if c.sanitize != nil {
2208 c.sanitize.begin(ctx)
2209 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002210 if c.coverage != nil {
2211 c.coverage.begin(ctx)
2212 }
Yi Kong9723e332023-12-04 14:52:53 +09002213 if c.afdo != nil {
2214 c.afdo.begin(ctx)
2215 }
Stephen Craneba090d12017-05-09 15:44:35 -07002216 if c.lto != nil {
2217 c.lto.begin(ctx)
2218 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002219 if c.orderfile != nil {
2220 c.orderfile.begin(ctx)
2221 }
Dan Albert92fe7402020-07-15 13:33:30 -07002222 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002223 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002224 if err != nil {
2225 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002226 c.Properties.Sdk_version = nil
2227 } else {
2228 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002229 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002230 }
Colin Crossca860ac2016-01-04 14:34:37 -08002231}
2232
Colin Cross37047f12016-12-13 17:06:13 -08002233func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002234 deps := Deps{}
2235
Joe Onorato37f900c2023-07-18 16:58:16 -07002236 for _, generator := range c.generators {
2237 deps = generator.GeneratorDeps(ctx, deps)
2238 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002239 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002240 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002241 }
2242 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002243 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002244 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002245 if c.stl != nil {
2246 deps = c.stl.deps(ctx, deps)
2247 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002248 if c.coverage != nil {
2249 deps = c.coverage.deps(ctx, deps)
2250 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002251
Colin Crossb6715442017-10-24 11:13:31 -07002252 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2253 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2254 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2255 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2256 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2257 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002258 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002259 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002260
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002261 for _, lib := range deps.ReexportSharedLibHeaders {
2262 if !inList(lib, deps.SharedLibs) {
2263 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2264 }
2265 }
2266
2267 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002268 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2269 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 -07002270 }
2271 }
2272
Colin Cross5950f382016-12-13 12:50:57 -08002273 for _, lib := range deps.ReexportHeaderLibHeaders {
2274 if !inList(lib, deps.HeaderLibs) {
2275 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2276 }
2277 }
2278
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002279 for _, gen := range deps.ReexportGeneratedHeaders {
2280 if !inList(gen, deps.GeneratedHeaders) {
2281 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2282 }
2283 }
2284
Colin Crossc99deeb2016-04-11 15:06:20 -07002285 return deps
2286}
2287
Dan Albert7e9d2952016-08-04 13:02:36 -07002288func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002289 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002290 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002291 moduleContextImpl: moduleContextImpl{
2292 mod: c,
2293 },
2294 }
2295 ctx.ctx = ctx
2296
Colin Crossca860ac2016-01-04 14:34:37 -08002297 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002298}
2299
Jiyong Park7ed9de32018-10-15 22:25:07 +09002300// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002301func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002302 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2303 version := name[sharp+1:]
2304 libname := name[:sharp]
2305 return libname, version
2306 }
2307 return name, ""
2308}
2309
Dan Albert92fe7402020-07-15 13:33:30 -07002310func GetCrtVariations(ctx android.BottomUpMutatorContext,
2311 m LinkableInterface) []blueprint.Variation {
2312 if ctx.Os() != android.Android {
2313 return nil
2314 }
2315 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002316 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2317 minSdkVersion := m.MinSdkVersion()
2318 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2319 minSdkVersion = m.SdkVersion()
2320 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002321 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2322 if err != nil {
2323 ctx.PropertyErrorf("min_sdk_version", err.Error())
2324 }
Colin Cross363ec762023-01-13 13:45:14 -08002325
2326 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002327 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002328 if apiLevel.LessThan(minApiForArch) {
2329 apiLevel = minApiForArch
2330 }
2331
Dan Albert92fe7402020-07-15 13:33:30 -07002332 return []blueprint.Variation{
2333 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002334 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002335 }
2336 }
2337 return []blueprint.Variation{
2338 {Mutator: "sdk", Variation: ""},
2339 }
2340}
2341
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002342func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2343 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002344
2345 variations = append([]blueprint.Variation(nil), variations...)
2346
Liz Kammer23942242022-04-08 15:41:00 -04002347 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002348 // Version is explicitly specified. i.e. libFoo#30
2349 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002350 if tag, ok := depTag.(libraryDependencyTag); ok {
2351 tag.explicitlyVersioned = true
2352 } else {
2353 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2354 }
Colin Crosse7257d22020-09-24 09:56:18 -07002355 }
Colin Crosse7257d22020-09-24 09:56:18 -07002356
Colin Cross0de8a1e2020-09-18 14:15:30 -07002357 if far {
2358 ctx.AddFarVariationDependencies(variations, depTag, name)
2359 } else {
2360 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002361 }
2362}
2363
Kiyoung Kim487689e2022-07-26 09:48:22 +09002364func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2365 apiImportInfo := multitree.ApiImportInfo{}
2366
2367 if c.Device() {
2368 var apiImportModule []blueprint.Module
2369 if actx.OtherModuleExists("api_imports") {
2370 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2371 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
Colin Cross313aa542023-12-13 13:47:44 -08002372 apiInfo, _ := android.OtherModuleProvider(actx, apiImportModule[0], multitree.ApiImportsProvider)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002373 apiImportInfo = apiInfo
Colin Cross40213022023-12-13 15:19:49 -08002374 android.SetProvider(actx, multitree.ApiImportsProvider, apiInfo)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002375 }
2376 }
2377 }
2378
2379 return apiImportInfo
2380}
2381
Kiyoung Kim487689e2022-07-26 09:48:22 +09002382func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2383 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002384 return snapshot
2385 }
2386
2387 return lib
2388}
2389
Kiyoung Kim37693d02024-04-04 09:56:15 +09002390// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002391// of names:
2392//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002393// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002394//
2395// For each of these, it adds the name of the ndk_library module to the list of
2396// variant libs.
2397//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002398// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002399//
2400// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002401//
2402// The caller can then know to add the variantLibs dependencies differently from the
2403// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002404func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002405 variantLibs = []string{}
2406
2407 nonvariantLibs = []string{}
2408 for _, entry := range list {
2409 // strip #version suffix out
2410 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002411 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002412 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002413 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002414 nonvariantLibs = append(nonvariantLibs, entry)
2415 }
2416 }
2417 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002418
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002419}
2420
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002421func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2422 nonVariantLibs := []string{}
2423 variantLibs := []string{}
2424
2425 for _, lib := range libs {
2426 replaceLibName := GetReplaceModuleName(lib, replaceList)
2427 if replaceLibName == lib {
2428 // Do not handle any libs which are not in API imports
2429 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2430 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2431 variantLibs = append(variantLibs, replaceLibName)
2432 } else {
2433 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2434 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002435 }
2436
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002437 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002438}
2439
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002440func (c *Module) shouldUseApiSurface() bool {
2441 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2442 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2443 // LLNDK Variant
2444 return true
2445 }
2446
2447 if c.Properties.IsSdkVariant {
2448 // NDK Variant
2449 return true
2450 }
2451
2452 if c.isImportedApiLibrary() {
2453 // API Library should depend on API headers
2454 return true
2455 }
2456 }
2457
2458 return false
2459}
2460
Colin Cross1e676be2016-10-12 14:38:15 -07002461func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002462 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002463 return
2464 }
2465
Colin Cross37047f12016-12-13 17:06:13 -08002466 ctx := &depsContext{
2467 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002468 moduleContextImpl: moduleContextImpl{
2469 mod: c,
2470 },
2471 }
2472 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002473
Colin Crossc99deeb2016-04-11 15:06:20 -07002474 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002475 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002476
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002477 apiNdkLibs := []string{}
2478 apiLateNdkLibs := []string{}
2479
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002480 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002481 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2482 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2483 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2484 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2485 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002486 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002487
Yo Chiang219968c2020-09-22 18:45:04 +08002488 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2489
Dan Albert914449f2016-06-17 16:45:24 -07002490 variantNdkLibs := []string{}
2491 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002492 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002493 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2494 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2495 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002496 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002497
Colin Cross32ec36c2016-12-15 07:39:51 -08002498 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002499 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002500 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002501 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002502 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002503
Kiyoung Kim51279d32022-08-24 14:10:46 +09002504 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002505 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002506 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2507 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002508
Spandan Das73bcafc2022-08-18 23:26:00 +00002509 if c.isNDKStubLibrary() {
Jiyong Parkf8fab9b2024-09-02 15:24:15 +09002510 variationExists := actx.OtherModuleDependencyVariantExists(nil, lib)
2511 if variationExists {
2512 actx.AddVariationDependencies(nil, depTag, lib)
2513 } else {
2514 // dependencies to ndk_headers fall here as ndk_headers do not have
2515 // any variants.
2516 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
2517 }
Kiyoung Kim51279d32022-08-24 14:10:46 +09002518 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002519 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002520 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002521 } else {
2522 actx.AddVariationDependencies(nil, depTag, lib)
2523 }
2524 }
2525
Dan Albertf1d14c72020-07-30 14:32:55 -07002526 if c.isNDKStubLibrary() {
2527 // NDK stubs depend on their implementation because the ABI dumps are
2528 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002529
Spandan Das8b08aea2023-03-14 19:29:34 +00002530 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2531 c.ImageVariation(),
2532 blueprint.Variation{Mutator: "link", Variation: "shared"},
2533 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002534 }
2535
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002536 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2537 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2538 c.Target().NativeBridge == android.NativeBridgeDisabled {
2539 actx.AddVariationDependencies(
Jihoon Kang47e91842024-06-19 00:51:16 +00002540 []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}},
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002541 llndkHeaderLibTag,
2542 deps.LlndkHeaderLibs...)
2543 }
2544
Jiyong Park5d1598f2019-02-25 22:14:17 +09002545 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002546 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002547
Jiyong Park5d1598f2019-02-25 22:14:17 +09002548 actx.AddVariationDependencies([]blueprint.Variation{
2549 {Mutator: "link", Variation: "static"},
2550 }, depTag, lib)
2551 }
2552
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002553 for _, lib := range deps.StaticLibs {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002554 // Some dependencies listed in static_libs might actually be rust_ffi rlib variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002555 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002556
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002557 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002558 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002559 }
Jiyong Parke3867542020-12-03 17:28:25 +09002560 if inList(lib, deps.ExcludeLibsForApex) {
2561 depTag.excludeInApex = true
2562 }
Dan Willemsen59339a22018-07-22 21:18:45 -07002563 actx.AddVariationDependencies([]blueprint.Variation{
2564 {Mutator: "link", Variation: "static"},
2565 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002566 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002567
Jooyung Han75568392020-03-20 04:29:24 +09002568 // staticUnwinderDep is treated as staticDep for Q apexes
2569 // so that native libraries/binaries are linked with static unwinder
2570 // because Q libc doesn't have unwinder APIs
2571 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002572 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002573 actx.AddVariationDependencies([]blueprint.Variation{
2574 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002575 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002576 }
2577
Jiyong Park7ed9de32018-10-15 22:25:07 +09002578 // shared lib names without the #version suffix
2579 var sharedLibNames []string
2580
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002581 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002582 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002583 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002584 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002585 }
Jiyong Parke3867542020-12-03 17:28:25 +09002586 if inList(lib, deps.ExcludeLibsForApex) {
2587 depTag.excludeInApex = true
2588 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002589 if inList(lib, deps.ExcludeLibsForNonApex) {
2590 depTag.excludeInNonApex = true
2591 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002592
Jiyong Park73c54ee2019-10-22 20:31:18 +09002593 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002594 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2595 name = apiLibraryName
2596 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002597 sharedLibNames = append(sharedLibNames, name)
2598
Colin Crosse7257d22020-09-24 09:56:18 -07002599 variations := []blueprint.Variation{
2600 {Mutator: "link", Variation: "shared"},
2601 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002602
2603 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2604 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2605 }
2606
2607 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2608 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2609 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002610 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002611
Colin Crossfe9acfe2021-06-14 16:13:03 -07002612 for _, lib := range deps.LateStaticLibs {
2613 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2614 actx.AddVariationDependencies([]blueprint.Variation{
2615 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002616 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002617 }
2618
Colin Cross3e5e7782022-06-17 22:17:05 +00002619 for _, lib := range deps.UnexportedStaticLibs {
2620 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2621 actx.AddVariationDependencies([]blueprint.Variation{
2622 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002623 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002624 }
2625
Jiyong Park7ed9de32018-10-15 22:25:07 +09002626 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002627 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002628 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2629 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2630 // linking against both the stubs lib and the non-stubs lib at the same time.
2631 continue
2632 }
Colin Cross6e511a92020-07-27 21:26:48 -07002633 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002634 variations := []blueprint.Variation{
2635 {Mutator: "link", Variation: "shared"},
2636 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002637 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002638 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002639
Dan Willemsen59339a22018-07-22 21:18:45 -07002640 actx.AddVariationDependencies([]blueprint.Variation{
2641 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002642 }, dataLibDepTag, deps.DataLibs...)
2643
Colin Crossc8caa062021-09-24 16:50:14 -07002644 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2645
Chris Parsons79d66a52020-06-05 17:26:16 -04002646 actx.AddVariationDependencies([]blueprint.Variation{
2647 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002648 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002649
Colin Cross68861832016-07-08 10:41:41 -07002650 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002651
2652 for _, gen := range deps.GeneratedHeaders {
2653 depTag := genHeaderDepTag
2654 if inList(gen, deps.ReexportGeneratedHeaders) {
2655 depTag = genHeaderExportDepTag
2656 }
2657 actx.AddDependency(c, depTag, gen)
2658 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002659
Dan Albert92fe7402020-07-15 13:33:30 -07002660 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002661 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002662 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002663 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002664 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002665 }
Colin Crossc465efd2021-06-11 18:00:04 -07002666 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002667 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002668 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002669 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002670 if deps.DynamicLinker != "" {
2671 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002672 }
Dan Albert914449f2016-06-17 16:45:24 -07002673
2674 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002675
2676 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002677 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002678 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002679 {Mutator: "link", Variation: "shared"},
2680 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002681 actx.AddVariationDependencies([]blueprint.Variation{
2682 {Mutator: "version", Variation: version},
2683 {Mutator: "link", Variation: "shared"},
2684 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002685
2686 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002687 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002688 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002689 {Mutator: "link", Variation: "shared"},
2690 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002691 actx.AddVariationDependencies([]blueprint.Variation{
2692 {Mutator: "version", Variation: version},
2693 {Mutator: "link", Variation: "shared"},
2694 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002695
Vinh Tran367d89d2023-04-28 11:21:25 -04002696 if len(deps.AidlLibs) > 0 {
2697 actx.AddDependency(
2698 c,
2699 aidlLibraryTag,
2700 deps.AidlLibs...,
2701 )
2702 }
2703
Kiyoung Kimee58c932022-10-25 22:59:41 +09002704 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002705}
Colin Cross21b9a242015-03-24 14:15:58 -07002706
Colin Crosse40b4ea2018-10-02 22:25:58 -07002707func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002708 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002709 c.beginMutator(ctx)
2710 }
2711}
2712
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002713// Whether a module can link to another module, taking into
2714// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002715func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002716 tag blueprint.DependencyTag) {
2717
2718 switch t := tag.(type) {
2719 case dependencyTag:
2720 if t != vndkExtDepTag {
2721 return
2722 }
2723 case libraryDependencyTag:
2724 default:
2725 return
2726 }
2727
Ivan Lozanof9e21722020-12-02 09:00:51 -05002728 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002729 // Host code is not restricted
2730 return
2731 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002732
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002733 // TODO(b/244244438) : Remove this once all variants are implemented
2734 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2735 return
2736 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002737 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002738 // Platform code can link to anything
2739 return
2740 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002741 if from.InRamdisk() {
2742 // Ramdisk code is not NDK
2743 return
2744 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002745 if from.InVendorRamdisk() {
2746 // Vendor ramdisk code is not NDK
2747 return
2748 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002749 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002750 // Recovery code is not NDK
2751 return
2752 }
Colin Cross31076b32020-10-23 17:22:06 -07002753 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002754 if c.StubDecorator() {
2755 // These aren't real libraries, but are the stub shared libraries that are included in
2756 // the NDK.
2757 return
2758 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002759 if c.isImportedApiLibrary() {
2760 // Imported library from the API surface is a stub library built against interface definition.
2761 return
2762 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002763 }
Logan Chien834b9a62019-01-14 15:39:03 +08002764
Ivan Lozano52767be2019-10-18 14:49:46 -07002765 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002766 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2767 // to link to libc++ (non-NDK and without sdk_version).
2768 return
2769 }
2770
Ivan Lozano52767be2019-10-18 14:49:46 -07002771 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002772 // NDK code linking to platform code is never okay.
2773 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002774 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002775 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002776 }
2777
2778 // At this point we know we have two NDK libraries, but we need to
2779 // check that we're not linking against anything built against a higher
2780 // API level, as it is only valid to link against older or equivalent
2781 // APIs.
2782
Inseob Kim01a28722018-04-11 09:48:45 +09002783 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002784 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002785 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002786 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002787 // Current can't be linked against by anything else.
2788 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002789 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002790 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002791 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002792 if err != nil {
2793 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002794 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002795 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002796 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002797 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002798 if err != nil {
2799 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002800 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002801 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002802 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002803
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002804 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002805 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002806 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002807 }
2808 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002809 }
Dan Albert202fe492017-12-15 13:56:59 -08002810
2811 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002812 fromStl := from.SelectedStl()
2813 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002814 if fromStl == "" || toStl == "" {
2815 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002816 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002817 // We can be permissive with the system "STL" since it is only the C++
2818 // ABI layer, but in the future we should make sure that everyone is
2819 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002820 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002821 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002822 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2823 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002824 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002825}
2826
Jooyung Han479ca172020-10-19 18:51:07 +09002827func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2828 if c, ok := ctx.Module().(*Module); ok {
2829 ctx.VisitDirectDeps(func(dep android.Module) {
2830 depTag := ctx.OtherModuleDependencyTag(dep)
2831 ccDep, ok := dep.(LinkableInterface)
2832 if ok {
2833 checkLinkType(ctx, c, ccDep, depTag)
2834 }
2835 })
2836 }
2837}
2838
Jiyong Park5fb8c102018-04-09 12:03:06 +09002839// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002840// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2841// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002842// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002843func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2844 check := func(child, parent android.Module) bool {
2845 to, ok := child.(*Module)
2846 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002847 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002848 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002849
Jooyung Hana70f0672019-01-18 15:20:43 +09002850 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2851 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002852 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002853
Jiyong Park0474e1f2021-01-14 14:26:06 +09002854 // These dependencies are not excercised at runtime. Tracking these will give us
2855 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002856 depTag := ctx.OtherModuleDependencyTag(child)
2857 if IsHeaderDepTag(depTag) {
2858 return false
2859 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002860 if depTag == staticVariantTag {
2861 return false
2862 }
2863 if depTag == stubImplDepTag {
2864 return false
2865 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002866 if depTag == android.RequiredDepTag {
2867 return false
2868 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002869
Justin Yun63e9ec72020-10-29 16:49:43 +09002870 // Even if target lib has no vendor variant, keep checking dependency
2871 // graph in case it depends on vendor_available or product_available
2872 // but not double_loadable transtively.
2873 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002874 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002875 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002876
Jiyong Park0474e1f2021-01-14 14:26:06 +09002877 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2878 // one.
2879 if Bool(to.VendorProperties.Double_loadable) {
2880 return true
2881 }
2882
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002883 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002884 return false
2885 }
2886
Jooyung Hana70f0672019-01-18 15:20:43 +09002887 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2888 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002889 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002890 return false
2891 }
2892 if module, ok := ctx.Module().(*Module); ok {
2893 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002894 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002895 ctx.WalkDeps(check)
2896 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002897 }
2898 }
2899}
2900
Yu Liue4312402023-01-18 09:15:31 -08002901func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2902 // For the dependency from platform to apex, use the latest stubs
2903 apexSdkVersion := android.FutureApiLevel
2904 if !apexInfo.IsForPlatform() {
2905 apexSdkVersion = apexInfo.MinSdkVersion
2906 }
2907
2908 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2909 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2910 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2911 // (b/144430859)
2912 apexSdkVersion = android.FutureApiLevel
2913 }
2914
2915 return apexSdkVersion
2916}
2917
Colin Crossc99deeb2016-04-11 15:06:20 -07002918// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002919func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002920 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002921
Colin Cross0de8a1e2020-09-18 14:15:30 -07002922 var directStaticDeps []StaticLibraryInfo
2923 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002924
Colin Cross0de8a1e2020-09-18 14:15:30 -07002925 reexportExporter := func(exporter FlagExporterInfo) {
2926 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2927 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2928 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2929 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2930 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002931 }
2932
Colin Crossff694a82023-12-13 15:54:49 -08002933 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002934 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002935
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002936 skipModuleList := map[string]bool{}
2937
2938 var apiImportInfo multitree.ApiImportInfo
2939 hasApiImportInfo := false
2940
2941 ctx.VisitDirectDeps(func(dep android.Module) {
2942 if dep.Name() == "api_imports" {
Colin Cross313aa542023-12-13 13:47:44 -08002943 apiImportInfo, _ = android.OtherModuleProvider(ctx, dep, multitree.ApiImportsProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002944 hasApiImportInfo = true
2945 }
2946 })
2947
2948 if hasApiImportInfo {
2949 targetStubModuleList := map[string]string{}
2950 targetOrigModuleList := map[string]string{}
2951
2952 // Search for dependency which both original module and API imported library with APEX stub exists
2953 ctx.VisitDirectDeps(func(dep android.Module) {
2954 depName := ctx.OtherModuleName(dep)
2955 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
2956 targetStubModuleList[apiLibrary] = depName
2957 }
2958 })
2959 ctx.VisitDirectDeps(func(dep android.Module) {
2960 depName := ctx.OtherModuleName(dep)
2961 if origLibrary, ok := targetStubModuleList[depName]; ok {
2962 targetOrigModuleList[origLibrary] = depName
2963 }
2964 })
2965
2966 // Decide which library should be used between original and API imported library
2967 ctx.VisitDirectDeps(func(dep android.Module) {
2968 depName := ctx.OtherModuleName(dep)
2969 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00002970 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002971 skipModuleList[depName] = true
2972 } else {
2973 skipModuleList[apiLibrary] = true
2974 }
2975 }
2976 })
2977 }
2978
Colin Crossd11fcda2017-10-23 17:59:01 -07002979 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002980 depName := ctx.OtherModuleName(dep)
2981 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002982
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002983 if _, ok := skipModuleList[depName]; ok {
2984 // skip this module because original module or API imported module matching with this should be used instead.
2985 return
2986 }
2987
Dan Willemsen47450072021-10-19 20:24:49 -07002988 if depTag == android.DarwinUniversalVariantTag {
2989 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2990 return
2991 }
2992
Vinh Tran367d89d2023-04-28 11:21:25 -04002993 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08002994 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04002995 depPaths.AidlLibraryInfos = append(
2996 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08002997 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04002998 )
2999 }
3000 }
3001
Ivan Lozano52767be2019-10-18 14:49:46 -07003002 ccDep, ok := dep.(LinkableInterface)
3003 if !ok {
3004
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003005 // handling for a few module types that aren't cc Module but that are also supported
3006 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003007 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003008 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003009 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3010 genRule.GeneratedSourceFiles()...)
3011 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003012 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003013 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003014 // Support exported headers from a generated_sources dependency
3015 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003016 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003017 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003018 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003019 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003020 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003021 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003022 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003023 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003024 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3025 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003026 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003027 // 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 +09003028 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003029
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003030 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003031 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003032 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003033 }
Colin Crosscef792e2021-06-11 18:01:26 -07003034 case CrtBeginDepTag:
3035 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3036 case CrtEndDepTag:
3037 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003038 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003039 return
3040 }
3041
Colin Crossfe17f6f2019-03-28 19:30:56 -07003042 if depTag == android.ProtoPluginDepTag {
3043 return
3044 }
3045
Jiyong Park8bcf3c62024-03-18 18:37:10 +09003046 if depTag == android.RequiredDepTag {
3047 return
3048 }
3049
Colin Crossd11fcda2017-10-23 17:59:01 -07003050 if dep.Target().Os != ctx.Os() {
Steven Morelandaaae81f2024-08-27 22:55:48 +00003051 ctx.ModuleErrorf("OS mismatch between %q (%s) and %q (%s)", ctx.ModuleName(), ctx.Os().Name, depName, dep.Target().Os.Name)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003052 return
3053 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003054 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003055 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3056 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003057 return
3058 }
3059
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003060 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003061 // Skip reused objects for stub libraries, they use their own stub object file instead.
3062 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3063 // version mutator, so the stubs variant is created from the shared variant that
3064 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003065 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003066 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003067 objs := staticAnalogue.ReuseObjects
3068 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003069 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003070 reexportExporter(depExporterInfo)
3071 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003072 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003073 }
3074
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08003075 if depTag == llndkHeaderLibTag {
3076 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3077 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
3078 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3079 }
3080
Colin Cross6e511a92020-07-27 21:26:48 -07003081 linkFile := ccDep.OutputFile()
3082
3083 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3084 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003085 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003086 return
3087 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003088
Jiyong Parke3867542020-12-03 17:28:25 +09003089 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3090 return
3091 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003092 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3093 return
3094 }
Jiyong Parke3867542020-12-03 17:28:25 +09003095
Colin Cross313aa542023-12-13 13:47:44 -08003096 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003097
Colin Cross6e511a92020-07-27 21:26:48 -07003098 var ptr *android.Paths
3099 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003100
Colin Cross6e511a92020-07-27 21:26:48 -07003101 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003102
Colin Cross6e511a92020-07-27 21:26:48 -07003103 switch {
3104 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003105 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003106 if !ctx.Config().AllowMissingDependencies() {
3107 ctx.ModuleErrorf("module %q is not a header library", depName)
3108 } else {
3109 ctx.AddMissingDependencies([]string{depName})
3110 }
3111 return
3112 }
Colin Cross6e511a92020-07-27 21:26:48 -07003113 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003114 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003115 if !ctx.Config().AllowMissingDependencies() {
3116 ctx.ModuleErrorf("module %q is not a shared library", depName)
3117 } else {
3118 ctx.AddMissingDependencies([]string{depName})
3119 }
3120 return
3121 }
Jiyong Parke3867542020-12-03 17:28:25 +09003122
Jiyong Park7d55b612021-06-11 17:22:09 +09003123 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3124 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003125
Jiyong Park1ad8e162020-12-01 23:40:09 +09003126 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3127 // linkFile, depFile, and ptr.
3128 if c.IsStubs() {
3129 break
3130 }
3131
Colin Cross0de8a1e2020-09-18 14:15:30 -07003132 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3133 depFile = sharedLibraryInfo.TableOfContents
3134
Colin Cross6e511a92020-07-27 21:26:48 -07003135 ptr = &depPaths.SharedLibs
3136 switch libDepTag.Order {
3137 case earlyLibraryDependency:
3138 ptr = &depPaths.EarlySharedLibs
3139 depPtr = &depPaths.EarlySharedLibsDeps
3140 case normalLibraryDependency:
3141 ptr = &depPaths.SharedLibs
3142 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003143 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003144 case lateLibraryDependency:
3145 ptr = &depPaths.LateSharedLibs
3146 depPtr = &depPaths.LateSharedLibsDeps
3147 default:
3148 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003149 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003150
Colin Cross6e511a92020-07-27 21:26:48 -07003151 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003152 if ccDep.RustLibraryInterface() {
3153 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3154 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3155 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3156 if libDepTag.wholeStatic {
3157 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3158 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
Jiyong Park1ad8e162020-12-01 23:40:09 +09003159
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003160 // If whole_static, track this as we want to make sure that in a final linkage for a shared library,
3161 // exported functions from the rust generated staticlib still exported.
3162 if c.CcLibrary() && c.Shared() {
3163 c.WholeRustStaticlib = true
3164 }
Colin Cross6e511a92020-07-27 21:26:48 -07003165 }
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003166
Colin Cross6e511a92020-07-27 21:26:48 -07003167 } else {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003168 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3169 if !isStaticLib {
3170 if !ctx.Config().AllowMissingDependencies() {
3171 ctx.ModuleErrorf("module %q is not a static library", depName)
3172 } else {
3173 ctx.AddMissingDependencies([]string{depName})
3174 }
3175 return
Inseob Kimeec88e12020-01-22 11:11:29 +09003176 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003177
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003178 // Stubs lib doesn't link to the static lib dependencies. Don't set
3179 // linkFile, depFile, and ptr.
3180 if c.IsStubs() {
3181 break
3182 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003183
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003184 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
3185 if libDepTag.wholeStatic {
3186 ptr = &depPaths.WholeStaticLibs
3187 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3188 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
3189 } else {
3190 // This case normally catches prebuilt static
3191 // libraries, but it can also occur when
3192 // AllowMissingDependencies is on and the
3193 // dependencies has no sources of its own
3194 // but has a whole_static_libs dependency
3195 // on a missing library. We want to depend
3196 // on the .a file so that there is something
3197 // in the dependency tree that contains the
3198 // error rule for the missing transitive
3199 // dependency.
3200 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
3201 }
3202 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3203 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
3204 } else {
3205 switch libDepTag.Order {
3206 case earlyLibraryDependency:
3207 panic(fmt.Errorf("early static libs not supported"))
3208 case normalLibraryDependency:
3209 // static dependencies will be handled separately so they can be ordered
3210 // using transitive dependencies.
3211 ptr = nil
3212 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
3213 case lateLibraryDependency:
3214 ptr = &depPaths.LateStaticLibs
3215 default:
3216 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
3217 }
3218 }
3219
3220 // Collect any exported Rust rlib deps from static libraries which have been included as whole_static_libs
3221 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3222
3223 if libDepTag.unexportedSymbols {
3224 depPaths.LdFlags = append(depPaths.LdFlags,
3225 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3226 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003227 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003228 }
3229
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003230 if libDepTag.static() && !libDepTag.wholeStatic && !ccDep.RustLibraryInterface() {
Colin Cross6e511a92020-07-27 21:26:48 -07003231 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3232 ctx.ModuleErrorf("module %q not a static library", depName)
3233 return
3234 }
Logan Chien43d34c32017-12-20 01:17:32 +08003235
Colin Cross6e511a92020-07-27 21:26:48 -07003236 // When combining coverage files for shared libraries and executables, coverage files
3237 // in static libraries act as if they were whole static libraries. The same goes for
3238 // source based Abi dump files.
3239 if c, ok := ccDep.(*Module); ok {
3240 staticLib := c.linker.(libraryInterface)
3241 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3242 staticLib.objs().coverageFiles...)
3243 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3244 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003245 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003246 // Handle non-CC modules here
3247 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003248 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003249 }
3250 }
3251
Colin Cross6e511a92020-07-27 21:26:48 -07003252 if ptr != nil {
3253 if !linkFile.Valid() {
3254 if !ctx.Config().AllowMissingDependencies() {
3255 ctx.ModuleErrorf("module %q missing output file", depName)
3256 } else {
3257 ctx.AddMissingDependencies([]string{depName})
3258 }
3259 return
3260 }
3261 *ptr = append(*ptr, linkFile.Path())
3262 }
3263
3264 if depPtr != nil {
3265 dep := depFile
3266 if !dep.Valid() {
3267 dep = linkFile
3268 }
3269 *depPtr = append(*depPtr, dep.Path())
3270 }
3271
Colin Cross0de8a1e2020-09-18 14:15:30 -07003272 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3273 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3274 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3275 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003276 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3277
3278 // Only re-export RustRlibDeps for cc static libs
3279 if c.static() {
3280 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3281 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003282
3283 if libDepTag.reexportFlags {
3284 reexportExporter(depExporterInfo)
3285 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3286 // Re-exported shared library headers must be included as well since they can help us with type information
3287 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003288 c.sabi.Properties.ReexportedIncludes = append(
3289 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003290 c.sabi.Properties.ReexportedSystemIncludes = append(
3291 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003292 }
3293
Spandan Das3faa7922024-02-26 19:42:32 +00003294 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003295 switch {
3296 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003297 c.Properties.AndroidMkHeaderLibs = append(
3298 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003299 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003300 if lib := moduleLibraryInterface(dep); lib != nil {
3301 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003302 // Add the dependency to the APEX(es) providing the library so that
3303 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003304 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003305 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003306 c.Properties.ApexesProvidingSharedLibs = append(
3307 c.Properties.ApexesProvidingSharedLibs, an)
3308 }
3309 }
3310 }
3311
3312 // Note: the order of libs in this list is not important because
3313 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003314 c.Properties.AndroidMkSharedLibs = append(
3315 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003316 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003317 if !ccDep.RustLibraryInterface() {
3318 if libDepTag.wholeStatic {
3319 c.Properties.AndroidMkWholeStaticLibs = append(
3320 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3321 } else {
3322 c.Properties.AndroidMkStaticLibs = append(
3323 c.Properties.AndroidMkStaticLibs, makeLibName)
3324 }
Colin Cross6e511a92020-07-27 21:26:48 -07003325 }
3326 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003327 } else if !c.IsStubs() {
3328 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3329
Colin Cross6e511a92020-07-27 21:26:48 -07003330 switch depTag {
3331 case runtimeDepTag:
3332 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003333 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003334 case objDepTag:
3335 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3336 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003337 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003338 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003339 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003340 case dynamicLinkerDepTag:
3341 depPaths.DynamicLinker = linkFile
3342 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003343 }
Colin Crossca860ac2016-01-04 14:34:37 -08003344 })
3345
Jeff Gaston294356f2017-09-27 17:05:30 -07003346 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003347 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3348 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3349 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003350
Colin Crossdd84e052017-05-17 13:44:16 -07003351 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003352 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003353 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3354 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003355 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003356 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3357
Jiyong Park74955042019-10-22 20:19:51 +09003358 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3359 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003360 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003361 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003362 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003363 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003364
3365 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003366 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003367 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003368 }
Colin Crossdd84e052017-05-17 13:44:16 -07003369
Colin Crossca860ac2016-01-04 14:34:37 -08003370 return depPaths
3371}
3372
Spandan Das604f3762023-03-16 22:51:40 +00003373func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003374 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003375 thisModule, ok := ctx.Module().(android.ApexModule)
3376 if !ok {
3377 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3378 }
3379
Kiyoung Kimaa394802024-01-08 12:55:45 +09003380 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003381 bootstrap := false
3382 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3383 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3384 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003385 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003386 bootstrap = linkable.Bootstrap()
3387 }
3388
Colin Crossff694a82023-12-13 15:54:49 -08003389 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003390
3391 useStubs := false
3392
Kiyoung Kimaa394802024-01-08 12:55:45 +09003393 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003394 if !apexInfo.IsForPlatform() {
3395 // For platform libraries, use current version of LLNDK
3396 // If this is for use_vendor apex we will apply the same rules
3397 // of apex sdk enforcement below to choose right version.
3398 useStubs = true
3399 }
3400 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3401 // If not building for APEX or the containing APEX allows the use of
3402 // platform APIs, use stubs only when it is from an APEX (and not from
3403 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3404 // bootstrap modules, always link to non-stub variant
3405 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3406
3407 isApexImportedApiLibrary := false
3408
3409 if cc, ok := dep.(*Module); ok {
3410 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3411 if apiLibrary.hasApexStubs() {
3412 isApexImportedApiLibrary = true
3413 }
3414 }
3415 }
3416
3417 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3418
3419 if useStubs {
3420 // Another exception: if this module is a test for an APEX, then
3421 // it is linked with the non-stub variant of a module in the APEX
3422 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003423 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003424 for _, apexContents := range testFor.ApexContents {
3425 if apexContents.DirectlyInApex(depName) {
3426 useStubs = false
3427 break
3428 }
3429 }
3430 }
3431 if useStubs {
3432 // Yet another exception: If this module and the dependency are
3433 // available to the same APEXes then skip stubs between their
3434 // platform variants. This complements the test_for case above,
3435 // which avoids the stubs on a direct APEX library dependency, by
3436 // avoiding stubs for indirect test dependencies as well.
3437 //
3438 // TODO(b/183882457): This doesn't work if the two libraries have
3439 // only partially overlapping apex_available. For that test_for
3440 // modules would need to be split into APEX variants and resolved
3441 // separately for each APEX they have access to.
3442 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3443 useStubs = false
3444 }
3445 }
3446 } else {
3447 // If building for APEX, use stubs when the parent is in any APEX that
3448 // the child is not in.
3449 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3450 }
3451
3452 return useStubs
3453}
3454
3455// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3456// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3457// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3458// has different level of updatability. For example, if a library foo in an APEX depends on a
3459// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3460// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3461// same APEX as foo, the non-stub variant of bar is used.
3462func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3463 depTag := ctx.OtherModuleDependencyTag(dep)
3464 libDepTag, ok := depTag.(libraryDependencyTag)
3465 if !ok || !libDepTag.shared() {
3466 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3467 }
3468
Colin Cross313aa542023-12-13 13:47:44 -08003469 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3470 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3471 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003472
3473 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003474 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003475 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003476 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3477 toUse := stubs[len(stubs)-1]
3478 sharedLibraryInfo = toUse.SharedLibraryInfo
3479 depExporterInfo = toUse.FlagExporterInfo
3480 }
3481 }
3482 return sharedLibraryInfo, depExporterInfo
3483}
3484
Colin Cross0de8a1e2020-09-18 14:15:30 -07003485// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3486// to match the topological order of the dependency tree, including any static analogues of
3487// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3488// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003489func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3490 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003491 var staticPaths android.Paths
3492 for _, staticDep := range staticDeps {
3493 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3494 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3495 }
3496 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003497 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3498 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003499 }
3500 }
3501 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3502
3503 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3504
3505 // reorder the dependencies based on transitive dependencies
3506 staticPaths = android.FirstUniquePaths(staticPaths)
3507 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3508
3509 if len(orderedStaticPaths) != len(staticPaths) {
3510 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3511 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3512 }
3513
3514 return orderedStaticPaths, transitiveStaticLibs
3515}
3516
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003517// BaseLibName trims known prefixes and suffixes
3518func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003519 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3520 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003521 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003522 return libName
3523}
3524
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003525func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003526 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003527 ccDepModule, _ := ccDep.(*Module)
3528 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003529 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003530
Justin Yuncbca3732021-02-03 19:24:13 +09003531 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003532 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003533 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003534 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003535
Ivan Lozanod1dec542021-05-26 15:33:11 -04003536 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003537 }
3538 }
3539
Kiyoung Kim22152f62024-05-24 10:45:28 +09003540 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003541 // The vendor and product modules in Make will have been renamed to not conflict with the
3542 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003543 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003544 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003545 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003546 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003547 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003548 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003549 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003550 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003551 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003552 } else {
3553 return libName
3554 }
3555}
3556
Colin Crossca860ac2016-01-04 14:34:37 -08003557func (c *Module) InstallInData() bool {
3558 if c.installer == nil {
3559 return false
3560 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003561 return c.installer.inData()
3562}
3563
3564func (c *Module) InstallInSanitizerDir() bool {
3565 if c.installer == nil {
3566 return false
3567 }
3568 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003569 return true
3570 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003571 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003572}
3573
Yifan Hong1b3348d2020-01-21 15:53:22 -08003574func (c *Module) InstallInRamdisk() bool {
3575 return c.InRamdisk()
3576}
3577
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003578func (c *Module) InstallInVendorRamdisk() bool {
3579 return c.InVendorRamdisk()
3580}
3581
Jiyong Parkf9332f12018-02-01 00:54:12 +09003582func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003583 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003584}
3585
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003586func (c *Module) MakeUninstallable() {
3587 if c.installer == nil {
3588 c.ModuleBase.MakeUninstallable()
3589 return
3590 }
3591 c.installer.makeUninstallable(c)
3592}
3593
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003594func (c *Module) HostToolPath() android.OptionalPath {
3595 if c.installer == nil {
3596 return android.OptionalPath{}
3597 }
3598 return c.installer.hostToolPath()
3599}
3600
Nan Zhangd4e641b2017-07-12 12:55:28 -07003601func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3602 return c.outputFile
3603}
3604
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003605func (c *Module) static() bool {
3606 if static, ok := c.linker.(interface {
3607 static() bool
3608 }); ok {
3609 return static.static()
3610 }
3611 return false
3612}
3613
Jiyong Park379de2f2018-12-19 02:47:14 +09003614func (c *Module) staticBinary() bool {
3615 if static, ok := c.linker.(interface {
3616 staticBinary() bool
3617 }); ok {
3618 return static.staticBinary()
3619 }
3620 return false
3621}
3622
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003623func (c *Module) testBinary() bool {
3624 if test, ok := c.linker.(interface {
3625 testBinary() bool
3626 }); ok {
3627 return test.testBinary()
3628 }
3629 return false
3630}
3631
Jingwen Chen537242c2022-08-24 11:53:27 +00003632func (c *Module) testLibrary() bool {
3633 if test, ok := c.linker.(interface {
3634 testLibrary() bool
3635 }); ok {
3636 return test.testLibrary()
3637 }
3638 return false
3639}
3640
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003641func (c *Module) benchmarkBinary() bool {
3642 if b, ok := c.linker.(interface {
3643 benchmarkBinary() bool
3644 }); ok {
3645 return b.benchmarkBinary()
3646 }
3647 return false
3648}
3649
3650func (c *Module) fuzzBinary() bool {
3651 if f, ok := c.linker.(interface {
3652 fuzzBinary() bool
3653 }); ok {
3654 return f.fuzzBinary()
3655 }
3656 return false
3657}
3658
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003659// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3660func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003661 if h, ok := c.linker.(interface {
3662 header() bool
3663 }); ok {
3664 return h.header()
3665 }
3666 return false
3667}
3668
Ivan Lozanod7586b62021-04-01 09:49:36 -04003669func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003670 if b, ok := c.linker.(interface {
3671 binary() bool
3672 }); ok {
3673 return b.binary()
3674 }
3675 return false
3676}
3677
Justin Yun5e035862021-06-29 20:50:37 +09003678func (c *Module) StaticExecutable() bool {
3679 if b, ok := c.linker.(*binaryDecorator); ok {
3680 return b.static()
3681 }
3682 return false
3683}
3684
Ivan Lozanod7586b62021-04-01 09:49:36 -04003685func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003686 if o, ok := c.linker.(interface {
3687 object() bool
3688 }); ok {
3689 return o.object()
3690 }
3691 return false
3692}
3693
Kiyoung Kim37693d02024-04-04 09:56:15 +09003694func (m *Module) Dylib() bool {
3695 return false
3696}
3697
3698func (m *Module) Rlib() bool {
3699 return false
3700}
3701
Ivan Lozanof9e21722020-12-02 09:00:51 -05003702func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003703 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003704 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003705 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003706 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003707 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003708 return "native:product"
3709 }
Jooyung Han38002912019-05-16 04:01:54 +09003710 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003711 } else if c.InRamdisk() {
3712 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003713 } else if c.InVendorRamdisk() {
3714 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003715 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003716 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003717 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003718 return "native:ndk:none:none"
3719 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3720 //family, link := getNdkStlFamilyAndLinkType(c)
3721 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3722 } else {
3723 return "native:platform"
3724 }
3725}
3726
Jiyong Park9d452992018-10-03 00:38:19 +09003727// Overrides ApexModule.IsInstallabeToApex()
Colin Cross3a02c7b2024-05-21 13:46:22 -07003728// Only shared/runtime libraries .
Jiyong Park9d452992018-10-03 00:38:19 +09003729func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003730 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003731 // Stub libs and prebuilt libs in a versioned SDK are not
3732 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003733 return lib.shared() && !lib.buildStubs()
Jiyong Park9d452992018-10-03 00:38:19 +09003734 }
3735 return false
3736}
3737
Jiyong Parka90ca002019-10-07 15:47:24 +09003738func (c *Module) AvailableFor(what string) bool {
3739 if linker, ok := c.linker.(interface {
3740 availableFor(string) bool
3741 }); ok {
3742 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3743 } else {
3744 return c.ApexModuleBase.AvailableFor(what)
3745 }
3746}
3747
Jiyong Park62304bb2020-04-13 16:19:48 +09003748func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003749 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003750}
3751
Paul Duffin0cb37b92020-03-04 14:52:46 +00003752func (c *Module) EverInstallable() bool {
3753 return c.installer != nil &&
3754 // Check to see whether the module is actually ever installable.
3755 c.installer.everInstallable()
3756}
3757
Ivan Lozanod7586b62021-04-01 09:49:36 -04003758func (c *Module) PreventInstall() bool {
3759 return c.Properties.PreventInstall
3760}
3761
3762func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003763 if c.library != nil {
3764 if i := c.library.installable(); i != nil {
3765 return i
3766 }
3767 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003768 return c.Properties.Installable
3769}
3770
3771func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003772 ret := c.EverInstallable() &&
3773 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003774 proptools.BoolDefault(c.Installable(), true) &&
3775 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003776
3777 // The platform variant doesn't need further condition. Apex variants however might not
3778 // be installable because it will likely to be included in the APEX and won't appear
3779 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003780 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003781 return ret
3782 }
3783
3784 // Special case for modules that are configured to be installed to /data, which includes
3785 // test modules. For these modules, both APEX and non-APEX variants are considered as
3786 // installable. This is because even the APEX variants won't be included in the APEX, but
3787 // will anyway be installed to /data/*.
3788 // See b/146995717
3789 if c.InstallInData() {
3790 return ret
3791 }
3792
3793 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003794}
3795
Logan Chien41eabe62019-04-10 13:33:58 +08003796func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3797 if c.linker != nil {
3798 if library, ok := c.linker.(*libraryDecorator); ok {
3799 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3800 }
3801 }
3802}
3803
Jiyong Park45bf82e2020-12-15 22:29:02 +09003804var _ android.ApexModule = (*Module)(nil)
3805
3806// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003807func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003808 depTag := ctx.OtherModuleDependencyTag(dep)
3809 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3810
3811 if cc, ok := dep.(*Module); ok {
3812 if cc.HasStubsVariants() {
3813 if isLibDepTag && libDepTag.shared() {
3814 // dynamic dep to a stubs lib crosses APEX boundary
3815 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003816 }
Colin Cross6e511a92020-07-27 21:26:48 -07003817 if IsRuntimeDepTag(depTag) {
3818 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003819 return false
3820 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003821 }
Zhijun Heec285872021-04-24 10:47:08 -07003822 if cc.IsLlndk() {
3823 return false
3824 }
Colin Crossaac32222020-07-29 12:51:56 -07003825 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003826 // shared_lib dependency from a static lib is considered as crossing
3827 // the APEX boundary because the dependency doesn't actually is
3828 // linked; the dependency is used only during the compilation phase.
3829 return false
3830 }
Jiyong Parke3867542020-12-03 17:28:25 +09003831
3832 if isLibDepTag && libDepTag.excludeInApex {
3833 return false
3834 }
Colin Cross6e511a92020-07-27 21:26:48 -07003835 }
Colin Crossc1b36442021-05-06 13:42:48 -07003836 if depTag == stubImplDepTag {
3837 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003838 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003839 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003840 if depTag == staticVariantTag {
3841 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3842 // actually mean that the static lib (and its dependencies) are copied into the
3843 // APEX.
3844 return false
3845 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003846 return true
3847}
3848
Jiyong Park45bf82e2020-12-15 22:29:02 +09003849// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003850func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3851 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003852 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3853 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3854 return nil
3855 }
Jooyung Han749dc692020-04-15 11:03:39 +09003856 // We don't check for prebuilt modules
3857 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3858 return nil
3859 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003860
Jooyung Han749dc692020-04-15 11:03:39 +09003861 minSdkVersion := c.MinSdkVersion()
3862 if minSdkVersion == "apex_inherit" {
3863 return nil
3864 }
3865 if minSdkVersion == "" {
3866 // JNI libs within APK-in-APEX fall into here
3867 // Those are okay to set sdk_version instead
3868 // We don't have to check if this is a SDK variant because
3869 // non-SDK variant resets sdk_version, which works too.
3870 minSdkVersion = c.SdkVersion()
3871 }
Dan Albertc8060532020-07-22 22:32:17 -07003872 if minSdkVersion == "" {
3873 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3874 }
3875 // Not using nativeApiLevelFromUser because the context here is not
3876 // necessarily a native context.
3877 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003878 if err != nil {
3879 return err
3880 }
Dan Albertc8060532020-07-22 22:32:17 -07003881
Colin Cross8ca61c12022-10-06 21:00:14 -07003882 // A dependency only needs to support a min_sdk_version at least
3883 // as high as the api level that the architecture was introduced in.
3884 // This allows introducing new architectures in the platform that
3885 // need to be included in apexes that normally require an older
3886 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003887 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003888 if sdkVersion.LessThan(minApiForArch) {
3889 sdkVersion = minApiForArch
3890 }
3891
Dan Albertc8060532020-07-22 22:32:17 -07003892 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003893 return fmt.Errorf("newer SDK(%v)", ver)
3894 }
3895 return nil
3896}
3897
Paul Duffinb5769c12021-05-12 16:16:51 +01003898// Implements android.ApexModule
3899func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3900 // stub libraries and native bridge libraries are always available to platform
3901 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3902}
3903
Inseob Kima1888ce2022-10-04 14:42:02 +09003904func (c *Module) overriddenModules() []string {
3905 if o, ok := c.linker.(overridable); ok {
3906 return o.overriddenModules()
3907 }
3908 return nil
3909}
3910
Liz Kammer35ca77e2021-12-22 15:31:40 -05003911type moduleType int
3912
3913const (
3914 unknownType moduleType = iota
3915 binary
3916 object
3917 fullLibrary
3918 staticLibrary
3919 sharedLibrary
3920 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003921 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003922 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003923)
3924
3925func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003926 if c.testBinary() {
3927 // testBinary is also a binary, so this comes before the c.Binary()
3928 // conditional. A testBinary has additional implicit dependencies and
3929 // other test-only semantics.
3930 return testBin
3931 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003932 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003933 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003934 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003935 } else if c.testLibrary() {
3936 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3937 // will let them add implicit compile deps on gtest, for example.
3938 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003939 // For now, treat them as regular libraries.
3940 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003941 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003942 static := false
3943 shared := false
3944 if library, ok := c.linker.(*libraryDecorator); ok {
3945 static = library.MutatedProperties.BuildStatic
3946 shared = library.MutatedProperties.BuildShared
3947 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3948 static = library.MutatedProperties.BuildStatic
3949 shared = library.MutatedProperties.BuildShared
3950 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003951 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003952 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003953 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003954 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003955 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003956 return staticLibrary
3957 }
3958 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003959 } else if c.isNDKStubLibrary() {
3960 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003961 }
3962 return unknownType
3963}
3964
Colin Crosscfad1192015-11-02 16:43:11 -08003965// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003966type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003967 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003968 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003969 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003970}
3971
Patrice Arrudac249c712019-03-19 17:00:29 -07003972// cc_defaults provides a set of properties that can be inherited by other cc
3973// modules. A module can use the properties from a cc_defaults using
3974// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3975// merged (when possible) by prepending the default module's values to the
3976// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003977func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003978 return DefaultsFactory()
3979}
3980
Colin Cross36242852017-06-23 15:06:31 -07003981func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003982 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003983
Colin Cross36242852017-06-23 15:06:31 -07003984 module.AddProperties(props...)
3985 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003986 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003987 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003988 &BaseCompilerProperties{},
3989 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003990 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003991 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003992 &StaticProperties{},
3993 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003994 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003995 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003996 &TestLinkerProperties{},
3997 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003998 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003999 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004000 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004001 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004002 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004003 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004004 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004005 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004006 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004007 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004008 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004009 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00004010 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004011 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004012 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4013 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004014 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004015 )
Colin Crosscfad1192015-11-02 16:43:11 -08004016
Jooyung Hancc372c52019-09-25 15:18:44 +09004017 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004018
4019 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004020}
4021
Jiyong Park2286afd2020-06-16 21:58:53 +09004022func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004023 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004024}
4025
Kiyoung Kim51279d32022-08-24 14:10:46 +09004026func (c *Module) isImportedApiLibrary() bool {
4027 _, ok := c.linker.(*apiLibraryDecorator)
4028 return ok
4029}
4030
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004031func kytheExtractAllFactory() android.Singleton {
4032 return &kytheExtractAllSingleton{}
4033}
4034
4035type kytheExtractAllSingleton struct {
4036}
4037
4038func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4039 var xrefTargets android.Paths
4040 ctx.VisitAllModules(func(module android.Module) {
4041 if ccModule, ok := module.(xref); ok {
4042 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4043 }
4044 })
4045 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4046 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004047 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004048 }
4049}
4050
Jihoon Kangf78a8902022-09-01 22:47:07 +00004051func (c *Module) Partition() string {
4052 if p, ok := c.installer.(interface {
4053 getPartition() string
4054 }); ok {
4055 return p.getPartition()
4056 }
4057 return ""
4058}
4059
Spandan Das2b6dfb52024-01-19 00:22:22 +00004060type sourceModuleName interface {
4061 sourceModuleName() string
4062}
4063
4064func (c *Module) BaseModuleName() string {
4065 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
4066 // if the prebuilt module sets a source_module_name in Android.bp, use that
4067 return smn.sourceModuleName()
4068 }
4069 return c.ModuleBase.BaseModuleName()
4070}
4071
Spandan Dase20c56c2024-07-23 21:34:24 +00004072func (c *Module) stubsSymbolFilePath() android.Path {
4073 if library, ok := c.linker.(*libraryDecorator); ok {
4074 return library.stubsSymbolFilePath
4075 }
4076 return android.OptionalPath{}.Path()
4077}
4078
Colin Cross06a931b2015-10-28 17:23:31 -07004079var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004080var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004081var BoolPtr = proptools.BoolPtr
4082var String = proptools.String
4083var StringPtr = proptools.StringPtr