blob: 134d89c0783cea9975f3a8ac1c83ac5c6ab563c6 [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Aditya Choudhary87b2ab22023-11-17 15:27:06 +000027 "android/soong/testing"
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +090028
Colin Cross97ba0732015-03-23 17:50:24 -070029 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070030 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070031
Vinh Tran367d89d2023-04-28 11:21:25 -040032 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070033 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070034 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070035 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070036 "android/soong/genrule"
Kiyoung Kim487689e2022-07-26 09:48:22 +090037 "android/soong/multitree"
Colin Cross3f40fa42015-01-30 17:27:36 -080038)
39
Colin Cross463a90e2015-06-17 14:20:06 -070040func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000041 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070042
Inseob Kim3b244062023-07-11 13:31:36 +090043 pctx.Import("android/soong/android")
Paul Duffin036e7002019-12-19 19:16:28 +000044 pctx.Import("android/soong/cc/config")
45}
46
47func RegisterCCBuildComponents(ctx android.RegistrationContext) {
48 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
49
50 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000051 ctx.BottomUp("sdk", sdkMutator).Parallel()
Kiyoung Kim973cb6f2024-04-29 14:14:53 +090052 ctx.BottomUp("llndk", llndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070053 ctx.BottomUp("link", LinkageMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070054 ctx.BottomUp("version", versionMutator).Parallel()
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.
Paul Duffin13f02712020-03-06 12:30:43 +0000616 linkerSpecifiedDeps(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
Colin Crossc472d572015-03-17 15:06:21 -0700909}
910
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200911func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400912 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
913 if b, ok := c.compiler.(*baseCompiler); ok {
914 hasAidl = b.hasSrcExt(".aidl")
915 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
916 hasProto = b.hasSrcExt(".proto")
917 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
918 hasSysprop = b.hasSrcExt(".sysprop")
919 hasWinMsg = b.hasSrcExt(".mc")
920 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
921 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200922 c.AndroidModuleBase().AddJSONData(d)
923 (*d)["Cc"] = map[string]interface{}{
924 "SdkVersion": c.SdkVersion(),
925 "MinSdkVersion": c.MinSdkVersion(),
926 "VndkVersion": c.VndkVersion(),
927 "ProductSpecific": c.ProductSpecific(),
928 "SocSpecific": c.SocSpecific(),
929 "DeviceSpecific": c.DeviceSpecific(),
930 "InProduct": c.InProduct(),
931 "InVendor": c.InVendor(),
932 "InRamdisk": c.InRamdisk(),
933 "InVendorRamdisk": c.InVendorRamdisk(),
934 "InRecovery": c.InRecovery(),
935 "VendorAvailable": c.VendorAvailable(),
936 "ProductAvailable": c.ProductAvailable(),
937 "RamdiskAvailable": c.RamdiskAvailable(),
938 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
939 "RecoveryAvailable": c.RecoveryAvailable(),
940 "OdmAvailable": c.OdmAvailable(),
941 "InstallInData": c.InstallInData(),
942 "InstallInRamdisk": c.InstallInRamdisk(),
943 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
944 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
945 "InstallInRecovery": c.InstallInRecovery(),
946 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200947 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200948 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
949 "ApexSdkVersion": c.apexSdkVersion,
950 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400951 "AidlSrcs": hasAidl,
952 "LexSrcs": hasLex,
953 "ProtoSrcs": hasProto,
954 "RenderscriptSrcs": hasRenderscript,
955 "SyspropSrcs": hasSysprop,
956 "WinMsgSrcs": hasWinMsg,
957 "YaccSrsc": hasYacc,
958 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900959 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200960 }
961}
962
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500963func (c *Module) SetPreventInstall() {
964 c.Properties.PreventInstall = true
965}
966
967func (c *Module) SetHideFromMake() {
968 c.Properties.HideFromMake = true
969}
970
Ivan Lozanod7586b62021-04-01 09:49:36 -0400971func (c *Module) HiddenFromMake() bool {
972 return c.Properties.HideFromMake
973}
974
Cole Faust43ddd082024-06-17 12:32:40 -0700975func (c *Module) RequiredModuleNames(ctx android.ConfigAndErrorContext) []string {
976 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800977 if c.ImageVariation().Variation == android.CoreVariation {
978 required = append(required, c.Properties.Target.Platform.Required...)
979 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
980 } else if c.InRecovery() {
981 required = append(required, c.Properties.Target.Recovery.Required...)
982 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
983 }
984 return android.FirstUniqueStrings(required)
985}
986
Ivan Lozano52767be2019-10-18 14:49:46 -0700987func (c *Module) Toc() android.OptionalPath {
988 if c.linker != nil {
989 if library, ok := c.linker.(libraryInterface); ok {
990 return library.toc()
991 }
992 }
993 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
994}
995
996func (c *Module) ApiLevel() string {
997 if c.linker != nil {
998 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700999 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001000 }
1001 }
1002 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1003}
1004
1005func (c *Module) Static() bool {
1006 if c.linker != nil {
1007 if library, ok := c.linker.(libraryInterface); ok {
1008 return library.static()
1009 }
1010 }
1011 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1012}
1013
1014func (c *Module) Shared() bool {
1015 if c.linker != nil {
1016 if library, ok := c.linker.(libraryInterface); ok {
1017 return library.shared()
1018 }
1019 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001020
Ivan Lozano52767be2019-10-18 14:49:46 -07001021 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1022}
1023
1024func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001025 if c.stl != nil {
1026 return c.stl.Properties.SelectedStl
1027 }
1028 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001029}
1030
Ivan Lozano52767be2019-10-18 14:49:46 -07001031func (c *Module) NdkPrebuiltStl() bool {
1032 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1033 return true
1034 }
1035 return false
1036}
1037
1038func (c *Module) StubDecorator() bool {
1039 if _, ok := c.linker.(*stubDecorator); ok {
1040 return true
1041 }
1042 return false
1043}
1044
Yi Kong5786f5c2024-05-28 02:22:34 +09001045func (c *Module) OptimizeForSize() bool {
1046 return Bool(c.Properties.Optimize_for_size)
1047}
1048
Ivan Lozano52767be2019-10-18 14:49:46 -07001049func (c *Module) SdkVersion() string {
1050 return String(c.Properties.Sdk_version)
1051}
1052
Artur Satayev480e25b2020-04-27 18:53:18 +01001053func (c *Module) MinSdkVersion() string {
1054 return String(c.Properties.Min_sdk_version)
1055}
1056
Jiyong Park5df7bd32021-08-25 16:18:46 +09001057func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001058 if linker, ok := c.linker.(*objectLinker); ok {
1059 return linker.isCrt()
1060 }
1061 return false
1062}
1063
Jiyong Park5df7bd32021-08-25 16:18:46 +09001064func (c *Module) SplitPerApiLevel() bool {
1065 return c.canUseSdk() && c.isCrt()
1066}
1067
Colin Crossc511bc52020-04-07 16:50:32 +00001068func (c *Module) AlwaysSdk() bool {
1069 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1070}
1071
Ivan Lozano183a3212019-10-18 14:18:45 -07001072func (c *Module) CcLibrary() bool {
1073 if c.linker != nil {
1074 if _, ok := c.linker.(*libraryDecorator); ok {
1075 return true
1076 }
Colin Crossd48fe732020-09-23 20:37:24 -07001077 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1078 return true
1079 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001080 }
1081 return false
1082}
1083
1084func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001085 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001086 return true
1087 }
1088 return false
1089}
1090
Spandan Dase12d2522023-09-12 21:42:31 +00001091func (c *Module) IsNdkPrebuiltStl() bool {
1092 if c.linker == nil {
1093 return false
1094 }
1095 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1096 return true
1097 }
1098 return false
1099}
1100
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001101func (c *Module) RlibStd() bool {
1102 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1103}
1104
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001105func (c *Module) RustLibraryInterface() bool {
1106 return false
1107}
1108
Ivan Lozano0a468a42024-05-13 21:03:34 -04001109func (c *Module) CrateName() string {
1110 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1111}
1112
1113func (c *Module) ExportedCrateLinkDirs() []string {
1114 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1115}
1116
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001117func (c *Module) IsFuzzModule() bool {
1118 if _, ok := c.compiler.(*fuzzBinary); ok {
1119 return true
1120 }
1121 return false
1122}
1123
1124func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1125 return c.FuzzModule
1126}
1127
1128func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1129 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1130 return fuzzer.fuzzPackagedModule
1131 }
1132 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1133}
1134
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001135func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001136 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1137 return fuzzer.sharedLibraries
1138 }
1139 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1140}
1141
Ivan Lozano2b262972019-11-21 12:30:50 -08001142func (c *Module) NonCcVariants() bool {
1143 return false
1144}
1145
Ivan Lozano183a3212019-10-18 14:18:45 -07001146func (c *Module) SetStatic() {
1147 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001148 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001149 library.setStatic()
1150 return
1151 }
1152 }
1153 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1154}
1155
1156func (c *Module) SetShared() {
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 library.setShared()
1160 return
1161 }
1162 }
1163 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1164}
1165
1166func (c *Module) BuildStaticVariant() bool {
1167 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001168 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001169 return library.buildStatic()
1170 }
1171 }
1172 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1173}
1174
1175func (c *Module) BuildSharedVariant() bool {
1176 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001177 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001178 return library.buildShared()
1179 }
1180 }
1181 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1182}
1183
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04001184func (c *Module) BuildRlibVariant() bool {
1185 // cc modules can never build rlib variants
1186 return false
1187}
1188
1189func (c *Module) IsRustFFI() bool {
1190 // cc modules are not Rust modules
1191 return false
1192}
1193
Ivan Lozano183a3212019-10-18 14:18:45 -07001194func (c *Module) Module() android.Module {
1195 return c
1196}
1197
Jiyong Parkc20eee32018-09-05 22:36:17 +09001198func (c *Module) OutputFile() android.OptionalPath {
1199 return c.outputFile
1200}
1201
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001202func (c *Module) CoverageFiles() android.Paths {
1203 if c.linker != nil {
1204 if library, ok := c.linker.(libraryInterface); ok {
1205 return library.objs().coverageFiles
1206 }
1207 }
1208 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1209}
1210
Ivan Lozano183a3212019-10-18 14:18:45 -07001211var _ LinkableInterface = (*Module)(nil)
1212
Jiyong Park719b4462019-01-13 00:39:51 +09001213func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001214 if c.linker != nil {
1215 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001216 }
1217 return nil
1218}
1219
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001220func (c *Module) CoverageOutputFile() android.OptionalPath {
1221 if c.linker != nil {
1222 return c.linker.coverageOutputFilePath()
1223 }
1224 return android.OptionalPath{}
1225}
1226
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001227func (c *Module) RelativeInstallPath() string {
1228 if c.installer != nil {
1229 return c.installer.relativeInstallPath()
1230 }
1231 return ""
1232}
1233
Jooyung Han344d5432019-08-23 11:17:39 +09001234func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001235 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001236}
1237
Colin Cross36242852017-06-23 15:06:31 -07001238func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001239 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001240 for _, generator := range c.generators {
1241 c.AddProperties(generator.GeneratorProps()...)
1242 }
Colin Crossca860ac2016-01-04 14:34:37 -08001243 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001244 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001245 }
1246 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001247 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001248 }
1249 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001250 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001251 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001252 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001253 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001254 }
Colin Cross16b23492016-01-06 14:41:07 -08001255 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001256 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001257 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001258 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001259 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001260 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001261 if c.fuzzer != nil {
1262 c.AddProperties(c.fuzzer.props()...)
1263 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001264 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001265 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001266 }
Stephen Craneba090d12017-05-09 15:44:35 -07001267 if c.lto != nil {
1268 c.AddProperties(c.lto.props()...)
1269 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001270 if c.afdo != nil {
1271 c.AddProperties(c.afdo.props()...)
1272 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001273 if c.orderfile != nil {
1274 c.AddProperties(c.orderfile.props()...)
1275 }
Colin Crossca860ac2016-01-04 14:34:37 -08001276 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001277 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001278 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001279 // Allow test-only on libraries that are not cc_test_library
1280 if c.library != nil && !c.testLibrary() {
1281 c.AddProperties(&c.sourceProperties)
1282 }
Colin Crossc472d572015-03-17 15:06:21 -07001283
Colin Cross36242852017-06-23 15:06:31 -07001284 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001285 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001286 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001287
Colin Cross36242852017-06-23 15:06:31 -07001288 return c
Colin Crossc472d572015-03-17 15:06:21 -07001289}
1290
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001291// UseVndk() returns true if this module is built against VNDK.
1292// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001293func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001294 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001295}
1296
Colin Crossc511bc52020-04-07 16:50:32 +00001297func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001298 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001299 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001300}
1301
1302func (c *Module) UseSdk() bool {
1303 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001304 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001305 }
1306 return false
1307}
1308
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001309func (c *Module) isCoverageVariant() bool {
1310 return c.coverage.Properties.IsCoverageVariant
1311}
1312
Colin Cross95f1ca02020-10-29 20:47:22 -07001313func (c *Module) IsNdk(config android.Config) bool {
1314 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001315}
1316
Colin Cross127bb8b2020-12-16 16:46:01 -08001317func (c *Module) IsLlndk() bool {
1318 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001319}
1320
Colin Cross1f3f1302021-04-26 18:37:44 -07001321func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001322 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001323 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001324}
1325
Colin Cross5271fea2021-04-27 13:06:04 -07001326func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1327 lib := moduleLibraryInterface(m)
1328 return lib != nil && (lib.hasVendorPublicLibrary())
1329}
1330
1331// IsVendorPublicLibrary returns true for vendor public libraries.
1332func (c *Module) IsVendorPublicLibrary() bool {
1333 return c.VendorProperties.IsVendorPublicLibrary
1334}
1335
Ivan Lozanof1868af2022-04-12 13:08:36 -04001336func (c *Module) IsVndkPrebuiltLibrary() bool {
1337 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1338 return true
1339 }
1340 return false
1341}
1342
1343func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1344 return c.Properties.SdkAndPlatformVariantVisibleToMake
1345}
1346
Ivan Lozanod7586b62021-04-01 09:49:36 -04001347func (c *Module) HasLlndkStubs() bool {
1348 lib := moduleLibraryInterface(c)
1349 return lib != nil && lib.hasLLNDKStubs()
1350}
1351
1352func (c *Module) StubsVersion() string {
1353 if lib, ok := c.linker.(versionedInterface); ok {
1354 return lib.stubsVersion()
1355 }
1356 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1357}
1358
Colin Cross127bb8b2020-12-16 16:46:01 -08001359// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1360// and does not set llndk.vendor_available: false.
1361func (c *Module) isImplementationForLLNDKPublic() bool {
1362 library, _ := c.library.(*libraryDecorator)
1363 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001364 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001365}
1366
Colin Cross3513fb12024-01-24 14:44:47 -08001367func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001368 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001369 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001370 }
1371 return false
1372}
1373
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001374func (c *Module) isOrderfileCompile() bool {
1375 if orderfile := c.orderfile; orderfile != nil {
1376 return orderfile.Properties.OrderfileLoad
1377 }
1378 return false
1379}
1380
Yi Kongc702ebd2022-08-19 16:02:45 +08001381func (c *Module) isCfi() bool {
1382 if sanitize := c.sanitize; sanitize != nil {
Yi Kongddffe722023-07-18 16:40:36 +09001383 return Bool(sanitize.Properties.SanitizeMutated.Cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001384 }
1385 return false
1386}
1387
Yi Konged79fa32023-06-04 17:15:42 +09001388func (c *Module) isFuzzer() bool {
1389 if sanitize := c.sanitize; sanitize != nil {
1390 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1391 }
1392 return false
1393}
1394
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001395func (c *Module) isNDKStubLibrary() bool {
1396 if _, ok := c.compiler.(*stubDecorator); ok {
1397 return true
1398 }
1399 return false
1400}
1401
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001402func (c *Module) SubName() string {
1403 return c.Properties.SubName
1404}
1405
Jiyong Park25fc6a92018-11-18 18:02:45 +09001406func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001407 if lib := c.library; lib != nil {
1408 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001409 }
1410 return false
1411}
1412
1413func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001414 if lib := c.library; lib != nil {
1415 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001416 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001417 return false
1418}
1419
Alan Stokes73feba32022-11-14 12:21:24 +00001420func (c *Module) IsStubsImplementationRequired() bool {
1421 if lib := c.library; lib != nil {
1422 return lib.isStubsImplementationRequired()
1423 }
1424 return false
1425}
1426
Colin Cross0477b422020-10-13 18:43:54 -07001427// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1428// the implementation. If it is an implementation library it returns its own name.
1429func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1430 name := ctx.OtherModuleName(c)
1431 if versioned, ok := c.linker.(versionedInterface); ok {
1432 name = versioned.implementationModuleName(name)
1433 }
1434 return name
1435}
1436
Martin Stjernholm2856c662020-12-02 15:03:42 +00001437// Similar to ImplementationModuleName, but uses the Make variant of the module
1438// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1439// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1440// under the premise that the prebuilt module overrides its source counterpart
1441// if it is exposed to Make).
1442func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1443 name := c.BaseModuleName()
1444 if versioned, ok := c.linker.(versionedInterface); ok {
1445 name = versioned.implementationModuleName(name)
1446 }
1447 return name
1448}
1449
Jiyong Park7d55b612021-06-11 17:22:09 +09001450func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001451 return Bool(c.Properties.Bootstrap)
1452}
1453
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001454func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001455 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1456 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1457 return false
1458 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001459 return c.linker != nil && c.linker.nativeCoverage()
1460}
1461
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001462func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001463 if p, ok := c.linker.(SnapshotInterface); ok {
1464 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001465 }
1466 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001467}
1468
Jiyong Parkf1194352019-02-25 11:05:47 +09001469func isBionic(name string) bool {
1470 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001471 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001472 return true
1473 }
1474 return false
1475}
1476
Martin Stjernholm279de572019-09-10 23:18:20 +01001477func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001478 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001479 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001480 }
1481 return isBionic(name)
1482}
1483
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001484func (c *Module) XrefCcFiles() android.Paths {
1485 return c.kytheFiles
1486}
1487
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001488func (c *Module) isCfiAssemblySupportEnabled() bool {
1489 return c.sanitize != nil &&
1490 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1491}
1492
Inseob Kim800d1142021-06-14 12:03:51 +09001493func (c *Module) InstallInRoot() bool {
1494 return c.installer != nil && c.installer.installInRoot()
1495}
1496
Colin Crossca860ac2016-01-04 14:34:37 -08001497type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001498 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001499 moduleContextImpl
1500}
1501
Colin Cross37047f12016-12-13 17:06:13 -08001502type depsContext struct {
1503 android.BottomUpMutatorContext
1504 moduleContextImpl
1505}
1506
Colin Crossca860ac2016-01-04 14:34:37 -08001507type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001508 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001509 moduleContextImpl
1510}
1511
1512type moduleContextImpl struct {
1513 mod *Module
1514 ctx BaseModuleContext
1515}
1516
Colin Crossb98c8b02016-07-29 13:44:28 -07001517func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001518 return ctx.mod.toolchain(ctx.ctx)
1519}
1520
1521func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001522 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001523}
1524
1525func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001526 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001527}
1528
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001529func (ctx *moduleContextImpl) testBinary() bool {
1530 return ctx.mod.testBinary()
1531}
1532
Yi Kong56fc1b62022-09-06 16:24:00 +08001533func (ctx *moduleContextImpl) testLibrary() bool {
1534 return ctx.mod.testLibrary()
1535}
1536
Jiyong Park1d1119f2019-07-29 21:27:18 +09001537func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001538 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001539}
1540
Inseob Kim7f283f42020-06-01 21:53:49 +09001541func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001542 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001543}
1544
Inseob Kim1042d292020-06-01 23:23:05 +09001545func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001546 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001547}
1548
Yi Kong5786f5c2024-05-28 02:22:34 +09001549func (ctx *moduleContextImpl) optimizeForSize() bool {
1550 return ctx.mod.OptimizeForSize()
1551}
1552
Jooyung Hanccce2f22020-03-07 03:45:53 +09001553func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001554 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001555}
1556
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001557func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001558 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001559}
1560
1561func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001562 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001563 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001564 }
1565 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001566}
1567
Jiyong Parkb35a8192020-08-10 15:59:36 +09001568func (ctx *moduleContextImpl) minSdkVersion() string {
1569 ver := ctx.mod.MinSdkVersion()
1570 if ver == "apex_inherit" && !ctx.isForPlatform() {
1571 ver = ctx.apexSdkVersion().String()
1572 }
1573 if ver == "apex_inherit" || ver == "" {
1574 ver = ctx.sdkVersion()
1575 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001576
1577 if ctx.ctx.Device() {
1578 config := ctx.ctx.Config()
Kiyoung Kim8f05c542024-05-22 16:50:34 +09001579 if ctx.inVendor() {
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001580 // If building for vendor with final API, then use the latest _stable_ API as "current".
1581 if config.VendorApiLevelFrozen() && (ver == "" || ver == "current") {
1582 ver = config.PlatformSdkVersion().String()
1583 }
1584 }
1585 }
1586
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001587 // For crt objects, the meaning of min_sdk_version is very different from other types of
1588 // module. For them, min_sdk_version defines the oldest version that the build system will
1589 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1590 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1591 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001592 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1593 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1594 // support such an old version. The version is set to the later version in case when the
1595 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1596 // it's for an APEX.
1597 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1598 if ctx.isForPlatform() {
1599 ver = strconv.Itoa(android.FutureApiLevelInt)
1600 } else { // for apex
1601 ver = ctx.apexSdkVersion().String()
1602 if ver == "" { // in case when min_sdk_version was not set by the APEX
1603 ver = ctx.sdkVersion()
1604 }
1605 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001606 }
1607
Jiyong Parkb35a8192020-08-10 15:59:36 +09001608 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1609 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1610 minSdkVersionInt, err2 := strconv.Atoi(ver)
1611 if err == nil && err2 == nil {
1612 if sdkVersionInt < minSdkVersionInt {
1613 return strconv.Itoa(sdkVersionInt)
1614 }
1615 }
1616 return ver
1617}
1618
1619func (ctx *moduleContextImpl) isSdkVariant() bool {
1620 return ctx.mod.IsSdkVariant()
1621}
1622
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001623func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001624 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001625}
Justin Yun8effde42017-06-23 19:24:43 +09001626
Kiyoung Kimaa394802024-01-08 12:55:45 +09001627func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1628 return ctx.mod.InVendorOrProduct()
1629}
1630
Colin Cross95f1ca02020-10-29 20:47:22 -07001631func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1632 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001633}
1634
Colin Cross127bb8b2020-12-16 16:46:01 -08001635func (ctx *moduleContextImpl) IsLlndk() bool {
1636 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001637}
1638
Colin Cross127bb8b2020-12-16 16:46:01 -08001639func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1640 return ctx.mod.isImplementationForLLNDKPublic()
1641}
1642
Colin Cross3513fb12024-01-24 14:44:47 -08001643func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1644 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001645}
1646
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001647func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1648 return ctx.mod.isOrderfileCompile()
1649}
1650
Yi Kongc702ebd2022-08-19 16:02:45 +08001651func (ctx *moduleContextImpl) isCfi() bool {
1652 return ctx.mod.isCfi()
1653}
1654
Yi Konged79fa32023-06-04 17:15:42 +09001655func (ctx *moduleContextImpl) isFuzzer() bool {
1656 return ctx.mod.isFuzzer()
1657}
1658
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001659func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1660 return ctx.mod.isNDKStubLibrary()
1661}
1662
Colin Cross5271fea2021-04-27 13:06:04 -07001663func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1664 return ctx.mod.IsVendorPublicLibrary()
1665}
1666
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001667func (ctx *moduleContextImpl) selectedStl() string {
1668 if stl := ctx.mod.stl; stl != nil {
1669 return stl.Properties.SelectedStl
1670 }
1671 return ""
1672}
1673
Ivan Lozanobd721262018-11-27 14:33:03 -08001674func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1675 return ctx.mod.linker.useClangLld(actx)
1676}
1677
Colin Crossce75d2c2016-10-06 16:12:58 -07001678func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001679 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001680}
1681
Logan Chiene274fc92019-12-03 11:18:32 -08001682func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001683 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1684 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001685}
1686
Colin Crosse07f2312020-08-13 11:24:56 -07001687func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001688 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1689 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001690}
1691
Dan Albertc8060532020-07-22 22:32:17 -07001692func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001693 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001694}
1695
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001696func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001697 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001698}
1699
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001700func (ctx *moduleContextImpl) nativeCoverage() bool {
1701 return ctx.mod.nativeCoverage()
1702}
1703
Colin Cross56a83212020-09-15 18:30:11 -07001704func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1705 return ctx.mod.DirectlyInAnyApex()
1706}
1707
Colin Cross95b07f22020-12-16 11:06:50 -08001708func (ctx *moduleContextImpl) isPreventInstall() bool {
1709 return ctx.mod.Properties.PreventInstall
1710}
1711
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001712func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1713 shared := &ctx.mod.sharedFlags
1714 if shared.flagsMap == nil {
1715 shared.numSharedFlags = 0
1716 shared.flagsMap = make(map[string]string)
1717 }
1718 return shared
1719}
1720
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001721func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1722 return ctx.mod.isCfiAssemblySupportEnabled()
1723}
1724
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001725func (ctx *moduleContextImpl) notInPlatform() bool {
1726 return ctx.mod.NotInPlatform()
1727}
1728
Colin Cross635c3b02016-05-18 15:37:25 -07001729func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001730 return &Module{
1731 hod: hod,
1732 multilib: multilib,
1733 }
1734}
1735
Colin Cross635c3b02016-05-18 15:37:25 -07001736func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001737 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001738 module.features = []feature{
1739 &tidyFeature{},
1740 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001741 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001742 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001743 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001744 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001745 module.sabi = &sabi{}
Stephen Craneba090d12017-05-09 15:44:35 -07001746 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001747 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001748 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001749 return module
1750}
1751
Colin Crossce75d2c2016-10-06 16:12:58 -07001752func (c *Module) Prebuilt() *android.Prebuilt {
1753 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1754 return p.prebuilt()
1755 }
1756 return nil
1757}
1758
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001759func (c *Module) IsPrebuilt() bool {
1760 return c.Prebuilt() != nil
1761}
1762
Colin Crossce75d2c2016-10-06 16:12:58 -07001763func (c *Module) Name() string {
1764 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001765 if p, ok := c.linker.(interface {
1766 Name(string) string
1767 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001768 name = p.Name(name)
1769 }
1770 return name
1771}
1772
Alex Light3d673592019-01-18 14:37:31 -08001773func (c *Module) Symlinks() []string {
1774 if p, ok := c.installer.(interface {
1775 symlinkList() []string
1776 }); ok {
1777 return p.symlinkList()
1778 }
1779 return nil
1780}
1781
Chris Parsons216e10a2020-07-09 17:12:52 -04001782func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001783 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001784 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001785 }); ok {
1786 return p.dataPaths()
1787 }
1788 return nil
1789}
1790
Ivan Lozanof1868af2022-04-12 13:08:36 -04001791func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001792 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1793 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001794 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001795 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001796 if c.ProductSpecific() {
1797 // If the module is product specific with 'product_specific: true',
1798 // do not add a name suffix because it is a base module.
1799 return ""
1800 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001801 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001802 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001803 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001804 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001805 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001806 // add version suffix only if the module is using different vndk version than the
1807 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001808 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001809 }
1810 return nameSuffix
1811}
1812
Ivan Lozanof1868af2022-04-12 13:08:36 -04001813func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1814 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001815
1816 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001817 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001818 }
1819
Colin Cross127bb8b2020-12-16 16:46:01 -08001820 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001821 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001822 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1823 // added for product variant only when we have vendor and product variants with core
1824 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001825 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001826 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001827 subName += vendorPublicLibrarySuffix
1828 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001829 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1830 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001831 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001832 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001833 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001834 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001835 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001836 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001837 subName += RecoverySuffix
1838 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1839 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001840 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001841 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001842 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001843 } else if c.IsStubs() && c.IsSdkVariant() {
1844 // Public API surface (NDK)
1845 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1846 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001847 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001848
1849 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001850}
1851
Sam Delmerico75dbca22023-04-20 13:13:25 +00001852func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1853 ctx := &moduleContext{
1854 ModuleContext: actx,
1855 moduleContextImpl: moduleContextImpl{
1856 mod: c,
1857 },
1858 }
1859 ctx.ctx = ctx
1860 return ctx
1861}
1862
Spandan Das20fce2d2023-04-12 17:21:39 +00001863// TODO (b/277651159): Remove this allowlist
1864var (
1865 skipStubLibraryMultipleApexViolation = map[string]bool{
1866 "libclang_rt.asan": true,
1867 "libclang_rt.hwasan": true,
1868 // runtime apex
1869 "libc": true,
1870 "libc_hwasan": true,
1871 "libdl_android": true,
1872 "libm": true,
1873 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001874 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001875 // art apex
1876 "libandroidio": true,
1877 "libdexfile": true,
1878 "libnativebridge": true,
1879 "libnativehelper": true,
1880 "libnativeloader": true,
1881 "libsigchain": true,
1882 }
1883)
1884
1885// Returns true if a stub library could be installed in multiple apexes
1886func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1887 // If this is not an apex variant, no check necessary
1888 if !c.InAnyApex() {
1889 return false
1890 }
1891 // If this is not a stub library, no check necessary
1892 if !c.HasStubsVariants() {
1893 return false
1894 }
1895 // Skip the allowlist
1896 // Use BaseModuleName so that this matches prebuilts.
1897 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1898 return false
1899 }
1900
1901 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1902 // Stub libraries should not have more than one apex_available
1903 if len(aaWithoutTestApexes) > 1 {
1904 return true
1905 }
1906 // Stub libraries should not use the wildcard
1907 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1908 return true
1909 }
1910 // Default: no violation
1911 return false
1912}
1913
Chris Parsons8d6e4332021-02-22 16:13:50 -05001914func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001915 ctx := moduleContextFromAndroidModuleContext(actx, c)
1916
Inseob Kim37e0bb02024-04-29 15:54:44 +09001917 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
1918 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
1919 Logtags: c.logtagsPaths,
1920 })
1921
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001922 // If Test_only is set on a module in bp file, respect the setting, otherwise
1923 // see if is a known test module type.
1924 testOnly := c.testModule || c.testLibrary()
1925 if c.sourceProperties.Test_only != nil {
1926 testOnly = Bool(c.sourceProperties.Test_only)
1927 }
1928 // Keep before any early returns.
1929 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
1930 TestOnly: testOnly,
1931 TopLevelTarget: c.testModule,
1932 })
1933
Ivan Lozanof1868af2022-04-12 13:08:36 -04001934 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08001935 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001936 if !apexInfo.IsForPlatform() {
1937 c.hideApexVariantFromMake = true
1938 }
1939
Chris Parsonseefc9e62021-04-02 17:36:47 -04001940 c.makeLinkType = GetMakeLinkType(actx, c)
1941
Colin Crossf18e1102017-11-16 14:33:08 -08001942 deps := c.depsToPaths(ctx)
1943 if ctx.Failed() {
1944 return
1945 }
1946
Joe Onorato37f900c2023-07-18 16:58:16 -07001947 for _, generator := range c.generators {
1948 gen := generator.GeneratorSources(ctx)
1949 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
1950 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
1951 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
1952 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
1953 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
1954 if len(deps.Objs.objFiles) == 0 {
1955 // If we are reusuing object files (which happens when we're a shared library and we're
1956 // reusing our static variant's object files), then skip adding the actual source files,
1957 // because we already have the object for it.
1958 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
1959 }
1960 }
1961
1962 if ctx.Failed() {
1963 return
1964 }
1965
Spandan Das20fce2d2023-04-12 17:21:39 +00001966 if c.stubLibraryMultipleApexViolation(actx) {
1967 actx.PropertyErrorf("apex_available",
1968 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
1969 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001970 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1971 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001972 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1973 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001974 }
1975
Colin Crossca860ac2016-01-04 14:34:37 -08001976 flags := Flags{
1977 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001978 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001979 }
Joe Onorato37f900c2023-07-18 16:58:16 -07001980 for _, generator := range c.generators {
1981 flags = generator.GeneratorFlags(ctx, flags, deps)
1982 }
Colin Crossca860ac2016-01-04 14:34:37 -08001983 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001984 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001985 }
1986 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001987 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001988 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001989 if c.stl != nil {
1990 flags = c.stl.flags(ctx, flags)
1991 }
Colin Cross16b23492016-01-06 14:41:07 -08001992 if c.sanitize != nil {
1993 flags = c.sanitize.flags(ctx, flags)
1994 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001995 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001996 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001997 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001998 if c.fuzzer != nil {
1999 flags = c.fuzzer.flags(ctx, flags)
2000 }
Stephen Craneba090d12017-05-09 15:44:35 -07002001 if c.lto != nil {
2002 flags = c.lto.flags(ctx, flags)
2003 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002004 if c.afdo != nil {
2005 flags = c.afdo.flags(ctx, flags)
2006 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002007 if c.orderfile != nil {
2008 flags = c.orderfile.flags(ctx, flags)
2009 }
Colin Crossca860ac2016-01-04 14:34:37 -08002010 for _, feature := range c.features {
2011 flags = feature.flags(ctx, flags)
2012 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002013 if ctx.Failed() {
2014 return
2015 }
2016
Colin Cross4af21ed2019-11-04 09:37:55 -08002017 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2018 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2019 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002020
Colin Cross4af21ed2019-11-04 09:37:55 -08002021 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002022
2023 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002024 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002025 }
2026 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002027 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002028 }
2029
Colin Cross3e5e7782022-06-17 22:17:05 +00002030 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2031
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002032 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002033 // We need access to all the flags seen by a source file.
2034 if c.sabi != nil {
2035 flags = c.sabi.flags(ctx, flags)
2036 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002037
Colin Cross4af21ed2019-11-04 09:37:55 -08002038 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002039
Joe Onorato37f900c2023-07-18 16:58:16 -07002040 for _, generator := range c.generators {
2041 generator.GeneratorBuildActions(ctx, flags, deps)
2042 }
2043
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002044 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002045 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002046 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002047 if ctx.Failed() {
2048 return
2049 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002050 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002051 c.objFiles = objs.objFiles
2052 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002053 }
2054
Colin Crossca860ac2016-01-04 14:34:37 -08002055 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002056 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002057 if ctx.Failed() {
2058 return
2059 }
Colin Cross635c3b02016-05-18 15:37:25 -07002060 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002061
Chris Parsons94a0bba2021-06-04 15:03:47 -04002062 c.maybeUnhideFromMake()
Colin Crossce75d2c2016-10-06 16:12:58 -07002063 }
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002064 if c.testModule {
Colin Cross40213022023-12-13 15:19:49 -08002065 android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{})
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002066 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002067
Colin Cross40213022023-12-13 15:19:49 -08002068 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002069
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002070 if Bool(c.Properties.Cmake_snapshot_supported) {
2071 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2072 }
2073
Chris Parsons94a0bba2021-06-04 15:03:47 -04002074 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002075
2076 if c.linker != nil {
2077 moduleInfoJSON := ctx.ModuleInfoJSON()
2078 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2079 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2080 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2081 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2082 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2083
2084 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2085 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2086 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2087 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2088
2089 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2090 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2091 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2092 moduleInfoJSON.SubName += ".cfi"
2093 }
2094 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2095 moduleInfoJSON.SubName += ".hwasan"
2096 }
2097 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2098 moduleInfoJSON.SubName += ".scs"
2099 }
2100 }
2101 moduleInfoJSON.SubName += c.Properties.SubName
2102
2103 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2104 moduleInfoJSON.Uninstallable = true
2105 }
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002106 }
Wei Lia1aa2972024-06-21 13:08:51 -07002107
2108 buildComplianceMetadataInfo(ctx, c, deps)
mrziwangabdb2932024-06-18 12:43:41 -07002109
2110 c.setOutputFiles(ctx)
2111}
2112
2113func (c *Module) setOutputFiles(ctx ModuleContext) {
2114 if c.outputFile.Valid() {
2115 ctx.SetOutputFiles(android.Paths{c.outputFile.Path()}, "")
2116 } else {
2117 ctx.SetOutputFiles(android.Paths{}, "")
2118 }
2119 if c.linker != nil {
2120 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), "unstripped")
2121 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), "stripped_all")
2122 }
Wei Lia1aa2972024-06-21 13:08:51 -07002123}
2124
2125func buildComplianceMetadataInfo(ctx ModuleContext, c *Module, deps PathDeps) {
2126 // Dump metadata that can not be done in android/compliance-metadata.go
2127 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
2128 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.IS_STATIC_LIB, strconv.FormatBool(ctx.static()))
2129 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.BUILT_FILES, c.outputFile.String())
2130
2131 // Static deps
2132 staticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(false))
2133 staticDepNames := make([]string, 0, len(staticDeps))
2134 for _, dep := range staticDeps {
2135 staticDepNames = append(staticDepNames, dep.Name())
2136 }
2137
2138 staticDepPaths := make([]string, 0, len(deps.StaticLibs))
2139 for _, dep := range deps.StaticLibs {
2140 staticDepPaths = append(staticDepPaths, dep.String())
2141 }
2142 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEPS, android.FirstUniqueStrings(staticDepNames))
2143 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEP_FILES, android.FirstUniqueStrings(staticDepPaths))
2144
2145 // Whole static deps
2146 wholeStaticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(true))
2147 wholeStaticDepNames := make([]string, 0, len(wholeStaticDeps))
2148 for _, dep := range wholeStaticDeps {
2149 wholeStaticDepNames = append(wholeStaticDepNames, dep.Name())
2150 }
2151
2152 wholeStaticDepPaths := make([]string, 0, len(deps.WholeStaticLibs))
2153 for _, dep := range deps.WholeStaticLibs {
2154 wholeStaticDepPaths = append(wholeStaticDepPaths, dep.String())
2155 }
2156 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEPS, android.FirstUniqueStrings(wholeStaticDepNames))
2157 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEP_FILES, android.FirstUniqueStrings(wholeStaticDepPaths))
Chris Parsons94a0bba2021-06-04 15:03:47 -04002158}
2159
2160func (c *Module) maybeUnhideFromMake() {
2161 // If a lib is directly included in any of the APEXes or is not available to the
2162 // platform (which is often the case when the stub is provided as a prebuilt),
2163 // unhide the stubs variant having the latest version gets visible to make. In
2164 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2165 // force anything in the make world to link against the stubs library. (unless it
2166 // is explicitly referenced via .bootstrap suffix or the module is marked with
2167 // 'bootstrap: true').
2168 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002169 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002170 c.IsStubs() && !c.InVendorRamdisk() {
2171 c.Properties.HideFromMake = false // unhide
2172 // Note: this is still non-installable
2173 }
2174}
2175
Colin Cross8ff10582023-12-07 13:10:56 -08002176// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2177// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002178func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002179 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002180 // If the module has been specifically configure to not be installed then
2181 // hide from make as otherwise it will break when running inside make
2182 // as the output path to install will not be specified. Not all uninstallable
2183 // modules can be hidden from make as some are needed for resolving make side
2184 // dependencies.
2185 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002186 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002187 c.SkipInstall()
2188 }
2189
2190 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2191 // to allow using the outputs in a genrule.
2192 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002193 c.installer.install(ctx, c.outputFile.Path())
2194 if ctx.Failed() {
2195 return
Colin Crossca860ac2016-01-04 14:34:37 -08002196 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002197 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002198}
2199
Colin Cross0ea8ba82019-06-06 14:33:29 -07002200func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002201 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002202 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002203 }
Colin Crossca860ac2016-01-04 14:34:37 -08002204 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002205}
2206
Colin Crossca860ac2016-01-04 14:34:37 -08002207func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002208 for _, generator := range c.generators {
2209 generator.GeneratorInit(ctx)
2210 }
Colin Crossca860ac2016-01-04 14:34:37 -08002211 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002212 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002213 }
Colin Crossca860ac2016-01-04 14:34:37 -08002214 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002215 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002216 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002217 if c.stl != nil {
2218 c.stl.begin(ctx)
2219 }
Colin Cross16b23492016-01-06 14:41:07 -08002220 if c.sanitize != nil {
2221 c.sanitize.begin(ctx)
2222 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002223 if c.coverage != nil {
2224 c.coverage.begin(ctx)
2225 }
Yi Kong9723e332023-12-04 14:52:53 +09002226 if c.afdo != nil {
2227 c.afdo.begin(ctx)
2228 }
Stephen Craneba090d12017-05-09 15:44:35 -07002229 if c.lto != nil {
2230 c.lto.begin(ctx)
2231 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002232 if c.orderfile != nil {
2233 c.orderfile.begin(ctx)
2234 }
Dan Albert92fe7402020-07-15 13:33:30 -07002235 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002236 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002237 if err != nil {
2238 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002239 c.Properties.Sdk_version = nil
2240 } else {
2241 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002242 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002243 }
Colin Crossca860ac2016-01-04 14:34:37 -08002244}
2245
Colin Cross37047f12016-12-13 17:06:13 -08002246func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002247 deps := Deps{}
2248
Joe Onorato37f900c2023-07-18 16:58:16 -07002249 for _, generator := range c.generators {
2250 deps = generator.GeneratorDeps(ctx, deps)
2251 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002252 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002253 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002254 }
2255 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002256 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002257 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002258 if c.stl != nil {
2259 deps = c.stl.deps(ctx, deps)
2260 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002261 if c.coverage != nil {
2262 deps = c.coverage.deps(ctx, deps)
2263 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002264
Colin Crossb6715442017-10-24 11:13:31 -07002265 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2266 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2267 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2268 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2269 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2270 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002271 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002272 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002273
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002274 for _, lib := range deps.ReexportSharedLibHeaders {
2275 if !inList(lib, deps.SharedLibs) {
2276 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2277 }
2278 }
2279
2280 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002281 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2282 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 -07002283 }
2284 }
2285
Colin Cross5950f382016-12-13 12:50:57 -08002286 for _, lib := range deps.ReexportHeaderLibHeaders {
2287 if !inList(lib, deps.HeaderLibs) {
2288 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2289 }
2290 }
2291
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002292 for _, gen := range deps.ReexportGeneratedHeaders {
2293 if !inList(gen, deps.GeneratedHeaders) {
2294 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2295 }
2296 }
2297
Colin Crossc99deeb2016-04-11 15:06:20 -07002298 return deps
2299}
2300
Dan Albert7e9d2952016-08-04 13:02:36 -07002301func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002302 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002303 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002304 moduleContextImpl: moduleContextImpl{
2305 mod: c,
2306 },
2307 }
2308 ctx.ctx = ctx
2309
Colin Crossca860ac2016-01-04 14:34:37 -08002310 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002311}
2312
Jiyong Park7ed9de32018-10-15 22:25:07 +09002313// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002314func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002315 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2316 version := name[sharp+1:]
2317 libname := name[:sharp]
2318 return libname, version
2319 }
2320 return name, ""
2321}
2322
Dan Albert92fe7402020-07-15 13:33:30 -07002323func GetCrtVariations(ctx android.BottomUpMutatorContext,
2324 m LinkableInterface) []blueprint.Variation {
2325 if ctx.Os() != android.Android {
2326 return nil
2327 }
2328 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002329 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2330 minSdkVersion := m.MinSdkVersion()
2331 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2332 minSdkVersion = m.SdkVersion()
2333 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002334 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2335 if err != nil {
2336 ctx.PropertyErrorf("min_sdk_version", err.Error())
2337 }
Colin Cross363ec762023-01-13 13:45:14 -08002338
2339 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002340 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002341 if apiLevel.LessThan(minApiForArch) {
2342 apiLevel = minApiForArch
2343 }
2344
Dan Albert92fe7402020-07-15 13:33:30 -07002345 return []blueprint.Variation{
2346 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002347 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002348 }
2349 }
2350 return []blueprint.Variation{
2351 {Mutator: "sdk", Variation: ""},
2352 }
2353}
2354
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002355func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2356 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002357
2358 variations = append([]blueprint.Variation(nil), variations...)
2359
Liz Kammer23942242022-04-08 15:41:00 -04002360 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002361 // Version is explicitly specified. i.e. libFoo#30
2362 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002363 if tag, ok := depTag.(libraryDependencyTag); ok {
2364 tag.explicitlyVersioned = true
2365 } else {
2366 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2367 }
Colin Crosse7257d22020-09-24 09:56:18 -07002368 }
Colin Crosse7257d22020-09-24 09:56:18 -07002369
Colin Cross0de8a1e2020-09-18 14:15:30 -07002370 if far {
2371 ctx.AddFarVariationDependencies(variations, depTag, name)
2372 } else {
2373 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002374 }
2375}
2376
Kiyoung Kim487689e2022-07-26 09:48:22 +09002377func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2378 apiImportInfo := multitree.ApiImportInfo{}
2379
2380 if c.Device() {
2381 var apiImportModule []blueprint.Module
2382 if actx.OtherModuleExists("api_imports") {
2383 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2384 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
Colin Cross313aa542023-12-13 13:47:44 -08002385 apiInfo, _ := android.OtherModuleProvider(actx, apiImportModule[0], multitree.ApiImportsProvider)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002386 apiImportInfo = apiInfo
Colin Cross40213022023-12-13 15:19:49 -08002387 android.SetProvider(actx, multitree.ApiImportsProvider, apiInfo)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002388 }
2389 }
2390 }
2391
2392 return apiImportInfo
2393}
2394
Kiyoung Kim487689e2022-07-26 09:48:22 +09002395func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2396 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002397 return snapshot
2398 }
2399
2400 return lib
2401}
2402
Kiyoung Kim37693d02024-04-04 09:56:15 +09002403// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002404// of names:
2405//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002406// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002407//
2408// For each of these, it adds the name of the ndk_library module to the list of
2409// variant libs.
2410//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002411// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002412//
2413// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002414//
2415// The caller can then know to add the variantLibs dependencies differently from the
2416// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002417func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002418 variantLibs = []string{}
2419
2420 nonvariantLibs = []string{}
2421 for _, entry := range list {
2422 // strip #version suffix out
2423 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002424 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002425 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002426 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002427 nonvariantLibs = append(nonvariantLibs, entry)
2428 }
2429 }
2430 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002431
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002432}
2433
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002434func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2435 nonVariantLibs := []string{}
2436 variantLibs := []string{}
2437
2438 for _, lib := range libs {
2439 replaceLibName := GetReplaceModuleName(lib, replaceList)
2440 if replaceLibName == lib {
2441 // Do not handle any libs which are not in API imports
2442 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2443 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2444 variantLibs = append(variantLibs, replaceLibName)
2445 } else {
2446 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2447 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002448 }
2449
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002450 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002451}
2452
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002453func (c *Module) shouldUseApiSurface() bool {
2454 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2455 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2456 // LLNDK Variant
2457 return true
2458 }
2459
2460 if c.Properties.IsSdkVariant {
2461 // NDK Variant
2462 return true
2463 }
2464
2465 if c.isImportedApiLibrary() {
2466 // API Library should depend on API headers
2467 return true
2468 }
2469 }
2470
2471 return false
2472}
2473
Colin Cross1e676be2016-10-12 14:38:15 -07002474func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002475 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002476 return
2477 }
2478
Colin Cross37047f12016-12-13 17:06:13 -08002479 ctx := &depsContext{
2480 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002481 moduleContextImpl: moduleContextImpl{
2482 mod: c,
2483 },
2484 }
2485 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002486
Colin Crossc99deeb2016-04-11 15:06:20 -07002487 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002488 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002489
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002490 apiNdkLibs := []string{}
2491 apiLateNdkLibs := []string{}
2492
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002493 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002494 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2495 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2496 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2497 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2498 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002499 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002500
Yo Chiang219968c2020-09-22 18:45:04 +08002501 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2502
Dan Albert914449f2016-06-17 16:45:24 -07002503 variantNdkLibs := []string{}
2504 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002505 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002506 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2507 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2508 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002509 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002510
Colin Cross32ec36c2016-12-15 07:39:51 -08002511 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002512 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002513 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002514 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002515 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002516
Kiyoung Kim51279d32022-08-24 14:10:46 +09002517 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002518 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002519 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2520 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002521
Spandan Das73bcafc2022-08-18 23:26:00 +00002522 if c.isNDKStubLibrary() {
2523 // ndk_headers do not have any variations
2524 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002525 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002526 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002527 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002528 } else {
2529 actx.AddVariationDependencies(nil, depTag, lib)
2530 }
2531 }
2532
Dan Albertf1d14c72020-07-30 14:32:55 -07002533 if c.isNDKStubLibrary() {
2534 // NDK stubs depend on their implementation because the ABI dumps are
2535 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002536
Spandan Das8b08aea2023-03-14 19:29:34 +00002537 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2538 c.ImageVariation(),
2539 blueprint.Variation{Mutator: "link", Variation: "shared"},
2540 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002541 }
2542
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002543 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2544 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2545 c.Target().NativeBridge == android.NativeBridgeDisabled {
2546 actx.AddVariationDependencies(
Jihoon Kang47e91842024-06-19 00:51:16 +00002547 []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}},
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002548 llndkHeaderLibTag,
2549 deps.LlndkHeaderLibs...)
2550 }
2551
Jiyong Park5d1598f2019-02-25 22:14:17 +09002552 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002553 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002554
Jiyong Park5d1598f2019-02-25 22:14:17 +09002555 actx.AddVariationDependencies([]blueprint.Variation{
2556 {Mutator: "link", Variation: "static"},
2557 }, depTag, lib)
2558 }
2559
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002560 for _, lib := range deps.StaticLibs {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002561 // Some dependencies listed in static_libs might actually be rust_ffi rlib variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002562 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002563
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002564 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002565 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002566 }
Jiyong Parke3867542020-12-03 17:28:25 +09002567 if inList(lib, deps.ExcludeLibsForApex) {
2568 depTag.excludeInApex = true
2569 }
Dan Willemsen59339a22018-07-22 21:18:45 -07002570 actx.AddVariationDependencies([]blueprint.Variation{
2571 {Mutator: "link", Variation: "static"},
2572 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002573 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002574
Jooyung Han75568392020-03-20 04:29:24 +09002575 // staticUnwinderDep is treated as staticDep for Q apexes
2576 // so that native libraries/binaries are linked with static unwinder
2577 // because Q libc doesn't have unwinder APIs
2578 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002579 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002580 actx.AddVariationDependencies([]blueprint.Variation{
2581 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002582 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002583 }
2584
Jiyong Park7ed9de32018-10-15 22:25:07 +09002585 // shared lib names without the #version suffix
2586 var sharedLibNames []string
2587
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002588 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002589 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002590 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002591 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002592 }
Jiyong Parke3867542020-12-03 17:28:25 +09002593 if inList(lib, deps.ExcludeLibsForApex) {
2594 depTag.excludeInApex = true
2595 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002596 if inList(lib, deps.ExcludeLibsForNonApex) {
2597 depTag.excludeInNonApex = true
2598 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002599
Jiyong Park73c54ee2019-10-22 20:31:18 +09002600 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002601 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2602 name = apiLibraryName
2603 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002604 sharedLibNames = append(sharedLibNames, name)
2605
Colin Crosse7257d22020-09-24 09:56:18 -07002606 variations := []blueprint.Variation{
2607 {Mutator: "link", Variation: "shared"},
2608 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002609
2610 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2611 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2612 }
2613
2614 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2615 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2616 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002617 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002618
Colin Crossfe9acfe2021-06-14 16:13:03 -07002619 for _, lib := range deps.LateStaticLibs {
2620 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2621 actx.AddVariationDependencies([]blueprint.Variation{
2622 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002623 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002624 }
2625
Colin Cross3e5e7782022-06-17 22:17:05 +00002626 for _, lib := range deps.UnexportedStaticLibs {
2627 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2628 actx.AddVariationDependencies([]blueprint.Variation{
2629 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002630 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002631 }
2632
Jiyong Park7ed9de32018-10-15 22:25:07 +09002633 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002634 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002635 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2636 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2637 // linking against both the stubs lib and the non-stubs lib at the same time.
2638 continue
2639 }
Colin Cross6e511a92020-07-27 21:26:48 -07002640 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002641 variations := []blueprint.Variation{
2642 {Mutator: "link", Variation: "shared"},
2643 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002644 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002645 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002646
Dan Willemsen59339a22018-07-22 21:18:45 -07002647 actx.AddVariationDependencies([]blueprint.Variation{
2648 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002649 }, dataLibDepTag, deps.DataLibs...)
2650
Colin Crossc8caa062021-09-24 16:50:14 -07002651 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2652
Chris Parsons79d66a52020-06-05 17:26:16 -04002653 actx.AddVariationDependencies([]blueprint.Variation{
2654 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002655 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002656
Colin Cross68861832016-07-08 10:41:41 -07002657 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002658
2659 for _, gen := range deps.GeneratedHeaders {
2660 depTag := genHeaderDepTag
2661 if inList(gen, deps.ReexportGeneratedHeaders) {
2662 depTag = genHeaderExportDepTag
2663 }
2664 actx.AddDependency(c, depTag, gen)
2665 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002666
Dan Albert92fe7402020-07-15 13:33:30 -07002667 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002668 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002669 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002670 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002671 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002672 }
Colin Crossc465efd2021-06-11 18:00:04 -07002673 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002674 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002675 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002676 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002677 if deps.DynamicLinker != "" {
2678 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002679 }
Dan Albert914449f2016-06-17 16:45:24 -07002680
2681 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002682
2683 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002684 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002685 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002686 {Mutator: "link", Variation: "shared"},
2687 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002688 actx.AddVariationDependencies([]blueprint.Variation{
2689 {Mutator: "version", Variation: version},
2690 {Mutator: "link", Variation: "shared"},
2691 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002692
2693 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002694 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002695 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002696 {Mutator: "link", Variation: "shared"},
2697 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002698 actx.AddVariationDependencies([]blueprint.Variation{
2699 {Mutator: "version", Variation: version},
2700 {Mutator: "link", Variation: "shared"},
2701 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002702
Vinh Tran367d89d2023-04-28 11:21:25 -04002703 if len(deps.AidlLibs) > 0 {
2704 actx.AddDependency(
2705 c,
2706 aidlLibraryTag,
2707 deps.AidlLibs...,
2708 )
2709 }
2710
Kiyoung Kimee58c932022-10-25 22:59:41 +09002711 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002712}
Colin Cross21b9a242015-03-24 14:15:58 -07002713
Colin Crosse40b4ea2018-10-02 22:25:58 -07002714func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002715 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002716 c.beginMutator(ctx)
2717 }
2718}
2719
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002720// Whether a module can link to another module, taking into
2721// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002722func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002723 tag blueprint.DependencyTag) {
2724
2725 switch t := tag.(type) {
2726 case dependencyTag:
2727 if t != vndkExtDepTag {
2728 return
2729 }
2730 case libraryDependencyTag:
2731 default:
2732 return
2733 }
2734
Ivan Lozanof9e21722020-12-02 09:00:51 -05002735 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002736 // Host code is not restricted
2737 return
2738 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002739
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002740 // TODO(b/244244438) : Remove this once all variants are implemented
2741 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2742 return
2743 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002744 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002745 // Platform code can link to anything
2746 return
2747 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002748 if from.InRamdisk() {
2749 // Ramdisk code is not NDK
2750 return
2751 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002752 if from.InVendorRamdisk() {
2753 // Vendor ramdisk code is not NDK
2754 return
2755 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002756 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002757 // Recovery code is not NDK
2758 return
2759 }
Colin Cross31076b32020-10-23 17:22:06 -07002760 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002761 if c.NdkPrebuiltStl() {
2762 // These are allowed, but they don't set sdk_version
2763 return
2764 }
2765 if c.StubDecorator() {
2766 // These aren't real libraries, but are the stub shared libraries that are included in
2767 // the NDK.
2768 return
2769 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002770 if c.isImportedApiLibrary() {
2771 // Imported library from the API surface is a stub library built against interface definition.
2772 return
2773 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002774 }
Logan Chien834b9a62019-01-14 15:39:03 +08002775
Ivan Lozano52767be2019-10-18 14:49:46 -07002776 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002777 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2778 // to link to libc++ (non-NDK and without sdk_version).
2779 return
2780 }
2781
Ivan Lozano52767be2019-10-18 14:49:46 -07002782 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002783 // NDK code linking to platform code is never okay.
2784 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002785 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002786 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002787 }
2788
2789 // At this point we know we have two NDK libraries, but we need to
2790 // check that we're not linking against anything built against a higher
2791 // API level, as it is only valid to link against older or equivalent
2792 // APIs.
2793
Inseob Kim01a28722018-04-11 09:48:45 +09002794 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002795 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002796 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002797 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002798 // Current can't be linked against by anything else.
2799 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002800 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002801 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002802 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002803 if err != nil {
2804 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002805 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002806 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002807 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002808 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002809 if err != nil {
2810 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002811 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002812 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002813 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002814
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002815 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002816 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002817 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002818 }
2819 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002820 }
Dan Albert202fe492017-12-15 13:56:59 -08002821
2822 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002823 fromStl := from.SelectedStl()
2824 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002825 if fromStl == "" || toStl == "" {
2826 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002827 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002828 // We can be permissive with the system "STL" since it is only the C++
2829 // ABI layer, but in the future we should make sure that everyone is
2830 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002831 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002832 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002833 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2834 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002835 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002836}
2837
Jooyung Han479ca172020-10-19 18:51:07 +09002838func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2839 if c, ok := ctx.Module().(*Module); ok {
2840 ctx.VisitDirectDeps(func(dep android.Module) {
2841 depTag := ctx.OtherModuleDependencyTag(dep)
2842 ccDep, ok := dep.(LinkableInterface)
2843 if ok {
2844 checkLinkType(ctx, c, ccDep, depTag)
2845 }
2846 })
2847 }
2848}
2849
Jiyong Park5fb8c102018-04-09 12:03:06 +09002850// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002851// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2852// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002853// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002854func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2855 check := func(child, parent android.Module) bool {
2856 to, ok := child.(*Module)
2857 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002858 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002859 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002860
Jooyung Hana70f0672019-01-18 15:20:43 +09002861 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2862 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002863 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002864
Jiyong Park0474e1f2021-01-14 14:26:06 +09002865 // These dependencies are not excercised at runtime. Tracking these will give us
2866 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002867 depTag := ctx.OtherModuleDependencyTag(child)
2868 if IsHeaderDepTag(depTag) {
2869 return false
2870 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002871 if depTag == staticVariantTag {
2872 return false
2873 }
2874 if depTag == stubImplDepTag {
2875 return false
2876 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002877 if depTag == android.RequiredDepTag {
2878 return false
2879 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002880
Justin Yun63e9ec72020-10-29 16:49:43 +09002881 // Even if target lib has no vendor variant, keep checking dependency
2882 // graph in case it depends on vendor_available or product_available
2883 // but not double_loadable transtively.
2884 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002885 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002886 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002887
Jiyong Park0474e1f2021-01-14 14:26:06 +09002888 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2889 // one.
2890 if Bool(to.VendorProperties.Double_loadable) {
2891 return true
2892 }
2893
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002894 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002895 return false
2896 }
2897
Jooyung Hana70f0672019-01-18 15:20:43 +09002898 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2899 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002900 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002901 return false
2902 }
2903 if module, ok := ctx.Module().(*Module); ok {
2904 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002905 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002906 ctx.WalkDeps(check)
2907 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002908 }
2909 }
2910}
2911
Yu Liue4312402023-01-18 09:15:31 -08002912func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2913 // For the dependency from platform to apex, use the latest stubs
2914 apexSdkVersion := android.FutureApiLevel
2915 if !apexInfo.IsForPlatform() {
2916 apexSdkVersion = apexInfo.MinSdkVersion
2917 }
2918
2919 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2920 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2921 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2922 // (b/144430859)
2923 apexSdkVersion = android.FutureApiLevel
2924 }
2925
2926 return apexSdkVersion
2927}
2928
Colin Crossc99deeb2016-04-11 15:06:20 -07002929// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002930func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002931 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002932
Colin Cross0de8a1e2020-09-18 14:15:30 -07002933 var directStaticDeps []StaticLibraryInfo
2934 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002935
Colin Cross0de8a1e2020-09-18 14:15:30 -07002936 reexportExporter := func(exporter FlagExporterInfo) {
2937 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2938 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2939 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2940 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2941 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002942 }
2943
Colin Crossff694a82023-12-13 15:54:49 -08002944 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002945 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002946
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002947 skipModuleList := map[string]bool{}
2948
2949 var apiImportInfo multitree.ApiImportInfo
2950 hasApiImportInfo := false
2951
2952 ctx.VisitDirectDeps(func(dep android.Module) {
2953 if dep.Name() == "api_imports" {
Colin Cross313aa542023-12-13 13:47:44 -08002954 apiImportInfo, _ = android.OtherModuleProvider(ctx, dep, multitree.ApiImportsProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002955 hasApiImportInfo = true
2956 }
2957 })
2958
2959 if hasApiImportInfo {
2960 targetStubModuleList := map[string]string{}
2961 targetOrigModuleList := map[string]string{}
2962
2963 // Search for dependency which both original module and API imported library with APEX stub exists
2964 ctx.VisitDirectDeps(func(dep android.Module) {
2965 depName := ctx.OtherModuleName(dep)
2966 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
2967 targetStubModuleList[apiLibrary] = depName
2968 }
2969 })
2970 ctx.VisitDirectDeps(func(dep android.Module) {
2971 depName := ctx.OtherModuleName(dep)
2972 if origLibrary, ok := targetStubModuleList[depName]; ok {
2973 targetOrigModuleList[origLibrary] = depName
2974 }
2975 })
2976
2977 // Decide which library should be used between original and API imported library
2978 ctx.VisitDirectDeps(func(dep android.Module) {
2979 depName := ctx.OtherModuleName(dep)
2980 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00002981 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002982 skipModuleList[depName] = true
2983 } else {
2984 skipModuleList[apiLibrary] = true
2985 }
2986 }
2987 })
2988 }
2989
Colin Crossd11fcda2017-10-23 17:59:01 -07002990 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002991 depName := ctx.OtherModuleName(dep)
2992 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002993
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002994 if _, ok := skipModuleList[depName]; ok {
2995 // skip this module because original module or API imported module matching with this should be used instead.
2996 return
2997 }
2998
Dan Willemsen47450072021-10-19 20:24:49 -07002999 if depTag == android.DarwinUniversalVariantTag {
3000 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3001 return
3002 }
3003
Vinh Tran367d89d2023-04-28 11:21:25 -04003004 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08003005 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04003006 depPaths.AidlLibraryInfos = append(
3007 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08003008 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04003009 )
3010 }
3011 }
3012
Ivan Lozano52767be2019-10-18 14:49:46 -07003013 ccDep, ok := dep.(LinkableInterface)
3014 if !ok {
3015
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003016 // handling for a few module types that aren't cc Module but that are also supported
3017 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003018 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003019 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003020 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3021 genRule.GeneratedSourceFiles()...)
3022 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003023 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003024 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003025 // Support exported headers from a generated_sources dependency
3026 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003027 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003028 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003029 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003030 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003031 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003032 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003033 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003034 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003035 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3036 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003037 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003038 // 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 +09003039 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003040
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003041 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003042 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003043 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003044 }
Colin Crosscef792e2021-06-11 18:01:26 -07003045 case CrtBeginDepTag:
3046 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3047 case CrtEndDepTag:
3048 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003049 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003050 return
3051 }
3052
Colin Crossfe17f6f2019-03-28 19:30:56 -07003053 if depTag == android.ProtoPluginDepTag {
3054 return
3055 }
3056
Jiyong Park8bcf3c62024-03-18 18:37:10 +09003057 if depTag == android.RequiredDepTag {
3058 return
3059 }
3060
Colin Crossd11fcda2017-10-23 17:59:01 -07003061 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003062 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3063 return
3064 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003065 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003066 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3067 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003068 return
3069 }
3070
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003071 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003072 // Skip reused objects for stub libraries, they use their own stub object file instead.
3073 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3074 // version mutator, so the stubs variant is created from the shared variant that
3075 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003076 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003077 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003078 objs := staticAnalogue.ReuseObjects
3079 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003080 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003081 reexportExporter(depExporterInfo)
3082 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003083 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003084 }
3085
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08003086 if depTag == llndkHeaderLibTag {
3087 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3088 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
3089 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3090 }
3091
Colin Cross6e511a92020-07-27 21:26:48 -07003092 linkFile := ccDep.OutputFile()
3093
3094 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3095 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003096 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003097 return
3098 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003099
Jiyong Parke3867542020-12-03 17:28:25 +09003100 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3101 return
3102 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003103 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3104 return
3105 }
Jiyong Parke3867542020-12-03 17:28:25 +09003106
Colin Cross313aa542023-12-13 13:47:44 -08003107 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003108
Colin Cross6e511a92020-07-27 21:26:48 -07003109 var ptr *android.Paths
3110 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003111
Colin Cross6e511a92020-07-27 21:26:48 -07003112 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003113
Colin Cross6e511a92020-07-27 21:26:48 -07003114 switch {
3115 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003116 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003117 if !ctx.Config().AllowMissingDependencies() {
3118 ctx.ModuleErrorf("module %q is not a header library", depName)
3119 } else {
3120 ctx.AddMissingDependencies([]string{depName})
3121 }
3122 return
3123 }
Colin Cross6e511a92020-07-27 21:26:48 -07003124 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003125 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003126 if !ctx.Config().AllowMissingDependencies() {
3127 ctx.ModuleErrorf("module %q is not a shared library", depName)
3128 } else {
3129 ctx.AddMissingDependencies([]string{depName})
3130 }
3131 return
3132 }
Jiyong Parke3867542020-12-03 17:28:25 +09003133
Jiyong Park7d55b612021-06-11 17:22:09 +09003134 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3135 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003136
Jiyong Park1ad8e162020-12-01 23:40:09 +09003137 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3138 // linkFile, depFile, and ptr.
3139 if c.IsStubs() {
3140 break
3141 }
3142
Colin Cross0de8a1e2020-09-18 14:15:30 -07003143 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3144 depFile = sharedLibraryInfo.TableOfContents
3145
Colin Cross6e511a92020-07-27 21:26:48 -07003146 ptr = &depPaths.SharedLibs
3147 switch libDepTag.Order {
3148 case earlyLibraryDependency:
3149 ptr = &depPaths.EarlySharedLibs
3150 depPtr = &depPaths.EarlySharedLibsDeps
3151 case normalLibraryDependency:
3152 ptr = &depPaths.SharedLibs
3153 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003154 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003155 case lateLibraryDependency:
3156 ptr = &depPaths.LateSharedLibs
3157 depPtr = &depPaths.LateSharedLibsDeps
3158 default:
3159 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003160 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003161
Colin Cross6e511a92020-07-27 21:26:48 -07003162 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003163 if ccDep.RustLibraryInterface() {
3164 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3165 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3166 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3167 if libDepTag.wholeStatic {
3168 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3169 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
Jiyong Park1ad8e162020-12-01 23:40:09 +09003170
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003171 // If whole_static, track this as we want to make sure that in a final linkage for a shared library,
3172 // exported functions from the rust generated staticlib still exported.
3173 if c.CcLibrary() && c.Shared() {
3174 c.WholeRustStaticlib = true
3175 }
Colin Cross6e511a92020-07-27 21:26:48 -07003176 }
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003177
Colin Cross6e511a92020-07-27 21:26:48 -07003178 } else {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003179 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3180 if !isStaticLib {
3181 if !ctx.Config().AllowMissingDependencies() {
3182 ctx.ModuleErrorf("module %q is not a static library", depName)
3183 } else {
3184 ctx.AddMissingDependencies([]string{depName})
3185 }
3186 return
Inseob Kimeec88e12020-01-22 11:11:29 +09003187 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003188
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003189 // Stubs lib doesn't link to the static lib dependencies. Don't set
3190 // linkFile, depFile, and ptr.
3191 if c.IsStubs() {
3192 break
3193 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003194
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003195 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
3196 if libDepTag.wholeStatic {
3197 ptr = &depPaths.WholeStaticLibs
3198 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3199 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
3200 } else {
3201 // This case normally catches prebuilt static
3202 // libraries, but it can also occur when
3203 // AllowMissingDependencies is on and the
3204 // dependencies has no sources of its own
3205 // but has a whole_static_libs dependency
3206 // on a missing library. We want to depend
3207 // on the .a file so that there is something
3208 // in the dependency tree that contains the
3209 // error rule for the missing transitive
3210 // dependency.
3211 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
3212 }
3213 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3214 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
3215 } else {
3216 switch libDepTag.Order {
3217 case earlyLibraryDependency:
3218 panic(fmt.Errorf("early static libs not supported"))
3219 case normalLibraryDependency:
3220 // static dependencies will be handled separately so they can be ordered
3221 // using transitive dependencies.
3222 ptr = nil
3223 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
3224 case lateLibraryDependency:
3225 ptr = &depPaths.LateStaticLibs
3226 default:
3227 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
3228 }
3229 }
3230
3231 // Collect any exported Rust rlib deps from static libraries which have been included as whole_static_libs
3232 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3233
3234 if libDepTag.unexportedSymbols {
3235 depPaths.LdFlags = append(depPaths.LdFlags,
3236 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3237 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003238 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003239 }
3240
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003241 if libDepTag.static() && !libDepTag.wholeStatic && !ccDep.RustLibraryInterface() {
Colin Cross6e511a92020-07-27 21:26:48 -07003242 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3243 ctx.ModuleErrorf("module %q not a static library", depName)
3244 return
3245 }
Logan Chien43d34c32017-12-20 01:17:32 +08003246
Colin Cross6e511a92020-07-27 21:26:48 -07003247 // When combining coverage files for shared libraries and executables, coverage files
3248 // in static libraries act as if they were whole static libraries. The same goes for
3249 // source based Abi dump files.
3250 if c, ok := ccDep.(*Module); ok {
3251 staticLib := c.linker.(libraryInterface)
3252 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3253 staticLib.objs().coverageFiles...)
3254 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3255 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003256 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003257 // Handle non-CC modules here
3258 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003259 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003260 }
3261 }
3262
Colin Cross6e511a92020-07-27 21:26:48 -07003263 if ptr != nil {
3264 if !linkFile.Valid() {
3265 if !ctx.Config().AllowMissingDependencies() {
3266 ctx.ModuleErrorf("module %q missing output file", depName)
3267 } else {
3268 ctx.AddMissingDependencies([]string{depName})
3269 }
3270 return
3271 }
3272 *ptr = append(*ptr, linkFile.Path())
3273 }
3274
3275 if depPtr != nil {
3276 dep := depFile
3277 if !dep.Valid() {
3278 dep = linkFile
3279 }
3280 *depPtr = append(*depPtr, dep.Path())
3281 }
3282
Colin Cross0de8a1e2020-09-18 14:15:30 -07003283 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3284 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3285 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3286 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003287 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3288
3289 // Only re-export RustRlibDeps for cc static libs
3290 if c.static() {
3291 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3292 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003293
3294 if libDepTag.reexportFlags {
3295 reexportExporter(depExporterInfo)
3296 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3297 // Re-exported shared library headers must be included as well since they can help us with type information
3298 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003299 c.sabi.Properties.ReexportedIncludes = append(
3300 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003301 c.sabi.Properties.ReexportedSystemIncludes = append(
3302 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003303 }
3304
Spandan Das3faa7922024-02-26 19:42:32 +00003305 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003306 switch {
3307 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003308 c.Properties.AndroidMkHeaderLibs = append(
3309 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003310 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003311 if lib := moduleLibraryInterface(dep); lib != nil {
3312 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003313 // Add the dependency to the APEX(es) providing the library so that
3314 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003315 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003316 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003317 c.Properties.ApexesProvidingSharedLibs = append(
3318 c.Properties.ApexesProvidingSharedLibs, an)
3319 }
3320 }
3321 }
3322
3323 // Note: the order of libs in this list is not important because
3324 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003325 c.Properties.AndroidMkSharedLibs = append(
3326 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003327 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003328 if !ccDep.RustLibraryInterface() {
3329 if libDepTag.wholeStatic {
3330 c.Properties.AndroidMkWholeStaticLibs = append(
3331 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3332 } else {
3333 c.Properties.AndroidMkStaticLibs = append(
3334 c.Properties.AndroidMkStaticLibs, makeLibName)
3335 }
Colin Cross6e511a92020-07-27 21:26:48 -07003336 }
3337 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003338 } else if !c.IsStubs() {
3339 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3340
Colin Cross6e511a92020-07-27 21:26:48 -07003341 switch depTag {
3342 case runtimeDepTag:
3343 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003344 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003345 case objDepTag:
3346 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3347 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003348 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003349 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003350 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003351 case dynamicLinkerDepTag:
3352 depPaths.DynamicLinker = linkFile
3353 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003354 }
Colin Crossca860ac2016-01-04 14:34:37 -08003355 })
3356
Jeff Gaston294356f2017-09-27 17:05:30 -07003357 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003358 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3359 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3360 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003361
Colin Crossdd84e052017-05-17 13:44:16 -07003362 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003363 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003364 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3365 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003366 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003367 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3368
Jiyong Park74955042019-10-22 20:19:51 +09003369 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3370 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003371 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003372 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003373 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003374 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003375
3376 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003377 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003378 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003379 }
Colin Crossdd84e052017-05-17 13:44:16 -07003380
Colin Crossca860ac2016-01-04 14:34:37 -08003381 return depPaths
3382}
3383
Spandan Das604f3762023-03-16 22:51:40 +00003384func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003385 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003386 thisModule, ok := ctx.Module().(android.ApexModule)
3387 if !ok {
3388 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3389 }
3390
Kiyoung Kimaa394802024-01-08 12:55:45 +09003391 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003392 bootstrap := false
3393 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3394 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3395 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003396 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003397 bootstrap = linkable.Bootstrap()
3398 }
3399
Colin Crossff694a82023-12-13 15:54:49 -08003400 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003401
3402 useStubs := false
3403
Kiyoung Kimaa394802024-01-08 12:55:45 +09003404 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003405 if !apexInfo.IsForPlatform() {
3406 // For platform libraries, use current version of LLNDK
3407 // If this is for use_vendor apex we will apply the same rules
3408 // of apex sdk enforcement below to choose right version.
3409 useStubs = true
3410 }
3411 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3412 // If not building for APEX or the containing APEX allows the use of
3413 // platform APIs, use stubs only when it is from an APEX (and not from
3414 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3415 // bootstrap modules, always link to non-stub variant
3416 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3417
3418 isApexImportedApiLibrary := false
3419
3420 if cc, ok := dep.(*Module); ok {
3421 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3422 if apiLibrary.hasApexStubs() {
3423 isApexImportedApiLibrary = true
3424 }
3425 }
3426 }
3427
3428 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3429
3430 if useStubs {
3431 // Another exception: if this module is a test for an APEX, then
3432 // it is linked with the non-stub variant of a module in the APEX
3433 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003434 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003435 for _, apexContents := range testFor.ApexContents {
3436 if apexContents.DirectlyInApex(depName) {
3437 useStubs = false
3438 break
3439 }
3440 }
3441 }
3442 if useStubs {
3443 // Yet another exception: If this module and the dependency are
3444 // available to the same APEXes then skip stubs between their
3445 // platform variants. This complements the test_for case above,
3446 // which avoids the stubs on a direct APEX library dependency, by
3447 // avoiding stubs for indirect test dependencies as well.
3448 //
3449 // TODO(b/183882457): This doesn't work if the two libraries have
3450 // only partially overlapping apex_available. For that test_for
3451 // modules would need to be split into APEX variants and resolved
3452 // separately for each APEX they have access to.
3453 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3454 useStubs = false
3455 }
3456 }
3457 } else {
3458 // If building for APEX, use stubs when the parent is in any APEX that
3459 // the child is not in.
3460 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3461 }
3462
3463 return useStubs
3464}
3465
3466// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3467// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3468// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3469// has different level of updatability. For example, if a library foo in an APEX depends on a
3470// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3471// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3472// same APEX as foo, the non-stub variant of bar is used.
3473func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3474 depTag := ctx.OtherModuleDependencyTag(dep)
3475 libDepTag, ok := depTag.(libraryDependencyTag)
3476 if !ok || !libDepTag.shared() {
3477 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3478 }
3479
Colin Cross313aa542023-12-13 13:47:44 -08003480 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3481 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3482 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003483
3484 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003485 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003486 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003487 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3488 toUse := stubs[len(stubs)-1]
3489 sharedLibraryInfo = toUse.SharedLibraryInfo
3490 depExporterInfo = toUse.FlagExporterInfo
3491 }
3492 }
3493 return sharedLibraryInfo, depExporterInfo
3494}
3495
Colin Cross0de8a1e2020-09-18 14:15:30 -07003496// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3497// to match the topological order of the dependency tree, including any static analogues of
3498// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3499// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003500func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3501 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003502 var staticPaths android.Paths
3503 for _, staticDep := range staticDeps {
3504 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3505 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3506 }
3507 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003508 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3509 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003510 }
3511 }
3512 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3513
3514 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3515
3516 // reorder the dependencies based on transitive dependencies
3517 staticPaths = android.FirstUniquePaths(staticPaths)
3518 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3519
3520 if len(orderedStaticPaths) != len(staticPaths) {
3521 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3522 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3523 }
3524
3525 return orderedStaticPaths, transitiveStaticLibs
3526}
3527
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003528// BaseLibName trims known prefixes and suffixes
3529func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003530 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3531 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003532 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003533 return libName
3534}
3535
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003536func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003537 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003538 ccDepModule, _ := ccDep.(*Module)
3539 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003540 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003541
Justin Yuncbca3732021-02-03 19:24:13 +09003542 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003543 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003544 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003545 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003546
Ivan Lozanod1dec542021-05-26 15:33:11 -04003547 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003548 }
3549 }
3550
Kiyoung Kim22152f62024-05-24 10:45:28 +09003551 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003552 // The vendor and product modules in Make will have been renamed to not conflict with the
3553 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003554 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003555 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003556 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003557 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003558 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003559 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003560 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003561 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003562 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003563 } else {
3564 return libName
3565 }
3566}
3567
Colin Crossca860ac2016-01-04 14:34:37 -08003568func (c *Module) InstallInData() bool {
3569 if c.installer == nil {
3570 return false
3571 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003572 return c.installer.inData()
3573}
3574
3575func (c *Module) InstallInSanitizerDir() bool {
3576 if c.installer == nil {
3577 return false
3578 }
3579 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003580 return true
3581 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003582 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003583}
3584
Yifan Hong1b3348d2020-01-21 15:53:22 -08003585func (c *Module) InstallInRamdisk() bool {
3586 return c.InRamdisk()
3587}
3588
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003589func (c *Module) InstallInVendorRamdisk() bool {
3590 return c.InVendorRamdisk()
3591}
3592
Jiyong Parkf9332f12018-02-01 00:54:12 +09003593func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003594 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003595}
3596
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003597func (c *Module) MakeUninstallable() {
3598 if c.installer == nil {
3599 c.ModuleBase.MakeUninstallable()
3600 return
3601 }
3602 c.installer.makeUninstallable(c)
3603}
3604
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003605func (c *Module) HostToolPath() android.OptionalPath {
3606 if c.installer == nil {
3607 return android.OptionalPath{}
3608 }
3609 return c.installer.hostToolPath()
3610}
3611
Nan Zhangd4e641b2017-07-12 12:55:28 -07003612func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3613 return c.outputFile
3614}
3615
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003616func (c *Module) static() bool {
3617 if static, ok := c.linker.(interface {
3618 static() bool
3619 }); ok {
3620 return static.static()
3621 }
3622 return false
3623}
3624
Jiyong Park379de2f2018-12-19 02:47:14 +09003625func (c *Module) staticBinary() bool {
3626 if static, ok := c.linker.(interface {
3627 staticBinary() bool
3628 }); ok {
3629 return static.staticBinary()
3630 }
3631 return false
3632}
3633
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003634func (c *Module) testBinary() bool {
3635 if test, ok := c.linker.(interface {
3636 testBinary() bool
3637 }); ok {
3638 return test.testBinary()
3639 }
3640 return false
3641}
3642
Jingwen Chen537242c2022-08-24 11:53:27 +00003643func (c *Module) testLibrary() bool {
3644 if test, ok := c.linker.(interface {
3645 testLibrary() bool
3646 }); ok {
3647 return test.testLibrary()
3648 }
3649 return false
3650}
3651
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003652func (c *Module) benchmarkBinary() bool {
3653 if b, ok := c.linker.(interface {
3654 benchmarkBinary() bool
3655 }); ok {
3656 return b.benchmarkBinary()
3657 }
3658 return false
3659}
3660
3661func (c *Module) fuzzBinary() bool {
3662 if f, ok := c.linker.(interface {
3663 fuzzBinary() bool
3664 }); ok {
3665 return f.fuzzBinary()
3666 }
3667 return false
3668}
3669
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003670// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3671func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003672 if h, ok := c.linker.(interface {
3673 header() bool
3674 }); ok {
3675 return h.header()
3676 }
3677 return false
3678}
3679
Ivan Lozanod7586b62021-04-01 09:49:36 -04003680func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003681 if b, ok := c.linker.(interface {
3682 binary() bool
3683 }); ok {
3684 return b.binary()
3685 }
3686 return false
3687}
3688
Justin Yun5e035862021-06-29 20:50:37 +09003689func (c *Module) StaticExecutable() bool {
3690 if b, ok := c.linker.(*binaryDecorator); ok {
3691 return b.static()
3692 }
3693 return false
3694}
3695
Ivan Lozanod7586b62021-04-01 09:49:36 -04003696func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003697 if o, ok := c.linker.(interface {
3698 object() bool
3699 }); ok {
3700 return o.object()
3701 }
3702 return false
3703}
3704
Kiyoung Kim37693d02024-04-04 09:56:15 +09003705func (m *Module) Dylib() bool {
3706 return false
3707}
3708
3709func (m *Module) Rlib() bool {
3710 return false
3711}
3712
Ivan Lozanof9e21722020-12-02 09:00:51 -05003713func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003714 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003715 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003716 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003717 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003718 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003719 return "native:product"
3720 }
Jooyung Han38002912019-05-16 04:01:54 +09003721 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003722 } else if c.InRamdisk() {
3723 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003724 } else if c.InVendorRamdisk() {
3725 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003726 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003727 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003728 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003729 return "native:ndk:none:none"
3730 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3731 //family, link := getNdkStlFamilyAndLinkType(c)
3732 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3733 } else {
3734 return "native:platform"
3735 }
3736}
3737
Jiyong Park9d452992018-10-03 00:38:19 +09003738// Overrides ApexModule.IsInstallabeToApex()
Colin Cross3a02c7b2024-05-21 13:46:22 -07003739// Only shared/runtime libraries .
Jiyong Park9d452992018-10-03 00:38:19 +09003740func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003741 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003742 // Stub libs and prebuilt libs in a versioned SDK are not
3743 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003744 return lib.shared() && !lib.buildStubs()
Jiyong Park9d452992018-10-03 00:38:19 +09003745 }
3746 return false
3747}
3748
Jiyong Parka90ca002019-10-07 15:47:24 +09003749func (c *Module) AvailableFor(what string) bool {
3750 if linker, ok := c.linker.(interface {
3751 availableFor(string) bool
3752 }); ok {
3753 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3754 } else {
3755 return c.ApexModuleBase.AvailableFor(what)
3756 }
3757}
3758
Jiyong Park62304bb2020-04-13 16:19:48 +09003759func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003760 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003761}
3762
Paul Duffin0cb37b92020-03-04 14:52:46 +00003763func (c *Module) EverInstallable() bool {
3764 return c.installer != nil &&
3765 // Check to see whether the module is actually ever installable.
3766 c.installer.everInstallable()
3767}
3768
Ivan Lozanod7586b62021-04-01 09:49:36 -04003769func (c *Module) PreventInstall() bool {
3770 return c.Properties.PreventInstall
3771}
3772
3773func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003774 if c.library != nil {
3775 if i := c.library.installable(); i != nil {
3776 return i
3777 }
3778 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003779 return c.Properties.Installable
3780}
3781
3782func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003783 ret := c.EverInstallable() &&
3784 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003785 proptools.BoolDefault(c.Installable(), true) &&
3786 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003787
3788 // The platform variant doesn't need further condition. Apex variants however might not
3789 // be installable because it will likely to be included in the APEX and won't appear
3790 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003791 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003792 return ret
3793 }
3794
3795 // Special case for modules that are configured to be installed to /data, which includes
3796 // test modules. For these modules, both APEX and non-APEX variants are considered as
3797 // installable. This is because even the APEX variants won't be included in the APEX, but
3798 // will anyway be installed to /data/*.
3799 // See b/146995717
3800 if c.InstallInData() {
3801 return ret
3802 }
3803
3804 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003805}
3806
Logan Chien41eabe62019-04-10 13:33:58 +08003807func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3808 if c.linker != nil {
3809 if library, ok := c.linker.(*libraryDecorator); ok {
3810 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3811 }
3812 }
3813}
3814
Jiyong Park45bf82e2020-12-15 22:29:02 +09003815var _ android.ApexModule = (*Module)(nil)
3816
3817// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003818func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003819 depTag := ctx.OtherModuleDependencyTag(dep)
3820 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3821
3822 if cc, ok := dep.(*Module); ok {
3823 if cc.HasStubsVariants() {
3824 if isLibDepTag && libDepTag.shared() {
3825 // dynamic dep to a stubs lib crosses APEX boundary
3826 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003827 }
Colin Cross6e511a92020-07-27 21:26:48 -07003828 if IsRuntimeDepTag(depTag) {
3829 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003830 return false
3831 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003832 }
Zhijun Heec285872021-04-24 10:47:08 -07003833 if cc.IsLlndk() {
3834 return false
3835 }
Colin Crossaac32222020-07-29 12:51:56 -07003836 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003837 // shared_lib dependency from a static lib is considered as crossing
3838 // the APEX boundary because the dependency doesn't actually is
3839 // linked; the dependency is used only during the compilation phase.
3840 return false
3841 }
Jiyong Parke3867542020-12-03 17:28:25 +09003842
3843 if isLibDepTag && libDepTag.excludeInApex {
3844 return false
3845 }
Colin Cross6e511a92020-07-27 21:26:48 -07003846 }
Colin Crossc1b36442021-05-06 13:42:48 -07003847 if depTag == stubImplDepTag {
3848 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003849 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003850 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003851 if depTag == staticVariantTag {
3852 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3853 // actually mean that the static lib (and its dependencies) are copied into the
3854 // APEX.
3855 return false
3856 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003857 return true
3858}
3859
Jiyong Park45bf82e2020-12-15 22:29:02 +09003860// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003861func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3862 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003863 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3864 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3865 return nil
3866 }
Jooyung Han749dc692020-04-15 11:03:39 +09003867 // We don't check for prebuilt modules
3868 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3869 return nil
3870 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003871
Jooyung Han749dc692020-04-15 11:03:39 +09003872 minSdkVersion := c.MinSdkVersion()
3873 if minSdkVersion == "apex_inherit" {
3874 return nil
3875 }
3876 if minSdkVersion == "" {
3877 // JNI libs within APK-in-APEX fall into here
3878 // Those are okay to set sdk_version instead
3879 // We don't have to check if this is a SDK variant because
3880 // non-SDK variant resets sdk_version, which works too.
3881 minSdkVersion = c.SdkVersion()
3882 }
Dan Albertc8060532020-07-22 22:32:17 -07003883 if minSdkVersion == "" {
3884 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3885 }
3886 // Not using nativeApiLevelFromUser because the context here is not
3887 // necessarily a native context.
3888 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003889 if err != nil {
3890 return err
3891 }
Dan Albertc8060532020-07-22 22:32:17 -07003892
Colin Cross8ca61c12022-10-06 21:00:14 -07003893 // A dependency only needs to support a min_sdk_version at least
3894 // as high as the api level that the architecture was introduced in.
3895 // This allows introducing new architectures in the platform that
3896 // need to be included in apexes that normally require an older
3897 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003898 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003899 if sdkVersion.LessThan(minApiForArch) {
3900 sdkVersion = minApiForArch
3901 }
3902
Dan Albertc8060532020-07-22 22:32:17 -07003903 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003904 return fmt.Errorf("newer SDK(%v)", ver)
3905 }
3906 return nil
3907}
3908
Paul Duffinb5769c12021-05-12 16:16:51 +01003909// Implements android.ApexModule
3910func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3911 // stub libraries and native bridge libraries are always available to platform
3912 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3913}
3914
Inseob Kima1888ce2022-10-04 14:42:02 +09003915func (c *Module) overriddenModules() []string {
3916 if o, ok := c.linker.(overridable); ok {
3917 return o.overriddenModules()
3918 }
3919 return nil
3920}
3921
Liz Kammer35ca77e2021-12-22 15:31:40 -05003922type moduleType int
3923
3924const (
3925 unknownType moduleType = iota
3926 binary
3927 object
3928 fullLibrary
3929 staticLibrary
3930 sharedLibrary
3931 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003932 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003933 ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00003934 ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05003935)
3936
3937func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003938 if c.testBinary() {
3939 // testBinary is also a binary, so this comes before the c.Binary()
3940 // conditional. A testBinary has additional implicit dependencies and
3941 // other test-only semantics.
3942 return testBin
3943 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003944 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003945 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003946 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003947 } else if c.testLibrary() {
3948 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3949 // will let them add implicit compile deps on gtest, for example.
3950 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003951 // For now, treat them as regular libraries.
3952 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003953 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003954 static := false
3955 shared := false
3956 if library, ok := c.linker.(*libraryDecorator); ok {
3957 static = library.MutatedProperties.BuildStatic
3958 shared = library.MutatedProperties.BuildShared
3959 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3960 static = library.MutatedProperties.BuildStatic
3961 shared = library.MutatedProperties.BuildShared
3962 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003963 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003964 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003965 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003966 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003967 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003968 return staticLibrary
3969 }
3970 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003971 } else if c.isNDKStubLibrary() {
3972 return ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00003973 } else if c.IsNdkPrebuiltStl() {
3974 return ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05003975 }
3976 return unknownType
3977}
3978
Colin Crosscfad1192015-11-02 16:43:11 -08003979// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003980type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003981 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003982 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003983 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003984}
3985
Patrice Arrudac249c712019-03-19 17:00:29 -07003986// cc_defaults provides a set of properties that can be inherited by other cc
3987// modules. A module can use the properties from a cc_defaults using
3988// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3989// merged (when possible) by prepending the default module's values to the
3990// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003991func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003992 return DefaultsFactory()
3993}
3994
Colin Cross36242852017-06-23 15:06:31 -07003995func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003996 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003997
Colin Cross36242852017-06-23 15:06:31 -07003998 module.AddProperties(props...)
3999 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004000 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004001 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004002 &BaseCompilerProperties{},
4003 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004004 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004005 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004006 &StaticProperties{},
4007 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004008 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004009 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004010 &TestLinkerProperties{},
4011 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004012 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004013 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004014 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004015 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004016 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004017 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004018 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004019 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004020 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004021 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004022 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004023 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00004024 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004025 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004026 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4027 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004028 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004029 )
Colin Crosscfad1192015-11-02 16:43:11 -08004030
Jooyung Hancc372c52019-09-25 15:18:44 +09004031 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004032
4033 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004034}
4035
Jiyong Park2286afd2020-06-16 21:58:53 +09004036func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004037 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004038}
4039
Kiyoung Kim51279d32022-08-24 14:10:46 +09004040func (c *Module) isImportedApiLibrary() bool {
4041 _, ok := c.linker.(*apiLibraryDecorator)
4042 return ok
4043}
4044
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004045func kytheExtractAllFactory() android.Singleton {
4046 return &kytheExtractAllSingleton{}
4047}
4048
4049type kytheExtractAllSingleton struct {
4050}
4051
4052func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4053 var xrefTargets android.Paths
4054 ctx.VisitAllModules(func(module android.Module) {
4055 if ccModule, ok := module.(xref); ok {
4056 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4057 }
4058 })
4059 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4060 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004061 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004062 }
4063}
4064
Jihoon Kangf78a8902022-09-01 22:47:07 +00004065func (c *Module) Partition() string {
4066 if p, ok := c.installer.(interface {
4067 getPartition() string
4068 }); ok {
4069 return p.getPartition()
4070 }
4071 return ""
4072}
4073
Spandan Das2b6dfb52024-01-19 00:22:22 +00004074type sourceModuleName interface {
4075 sourceModuleName() string
4076}
4077
4078func (c *Module) BaseModuleName() string {
4079 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
4080 // if the prebuilt module sets a source_module_name in Android.bp, use that
4081 return smn.sourceModuleName()
4082 }
4083 return c.ModuleBase.BaseModuleName()
4084}
4085
Colin Cross06a931b2015-10-28 17:23:31 -07004086var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004087var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004088var BoolPtr = proptools.BoolPtr
4089var String = proptools.String
4090var StringPtr = proptools.StringPtr