blob: df0aa6d681da4065460808b6dd606eb47eaa7449 [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()
Roland Levillain9b5fde92019-06-28 15:41:19 +010054 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070055 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070056 ctx.BottomUp("begin", BeginMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070057 })
Colin Cross16b23492016-01-06 14:41:07 -080058
Paul Duffin036e7002019-12-19 19:16:28 +000059 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040060 for _, san := range Sanitizers {
61 san.registerMutators(ctx)
62 }
Dan Willemsen581341d2017-02-09 16:16:31 -080063
Colin Cross0b908332019-06-19 23:00:20 -070064 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090065 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080066
Cory Barkera1da26f2022-06-07 20:12:06 +000067 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000068
Colin Crossf5f4ad32024-01-19 15:41:48 -080069 ctx.Transition("coverage", &coverageTransitionMutator{})
Stephen Craneba090d12017-05-09 15:44:35 -070070
Colin Crossd38feb02024-01-23 16:38:06 -080071 ctx.Transition("afdo", &afdoTransitionMutator{})
Yi Kongeb8efc92021-12-09 18:06:29 +080072
Colin Cross33e0c812024-01-23 16:36:07 -080073 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000074
Colin Cross6ac83a82024-01-23 11:23:10 -080075 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +090076
Jooyung Han479ca172020-10-19 18:51:07 +090077 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090078 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070079 })
Colin Crossb98c8b02016-07-29 13:44:28 -070080
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080081 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
82 // sabi mutator needs to be run after apex mutator finishes.
83 ctx.TopDown("sabi_deps", sabiDepsMutator)
84 })
85
LaMont Jones0c10e4d2023-05-16 00:58:37 +000086 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070087}
88
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050089// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
90// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
91// edges to these modules.
92// This object is constructed in DepsMutator, by calling to various module delegates to set
93// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
94// dependencies.
95// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
96// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080097type Deps struct {
98 SharedLibs, LateSharedLibs []string
99 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800100 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800101 RuntimeLibs []string
Ivan Lozano0a468a42024-05-13 21:03:34 -0400102 Rlibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700103
Colin Cross3e5e7782022-06-17 22:17:05 +0000104 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
105 // prevent automatically exporting symbols.
106 UnexportedStaticLibs []string
107
Chris Parsons79d66a52020-06-05 17:26:16 -0400108 // Used for data dependencies adjacent to tests
109 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700110 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400111
Yo Chiang219968c2020-09-22 18:45:04 +0800112 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
113 SystemSharedLibs []string
114
Vinh Tran367d89d2023-04-28 11:21:25 -0400115 // Used by DepMutator to pass aidl_library modules to aidl compiler
116 AidlLibs []string
117
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500118 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800119 StaticUnwinderIfLegacy bool
120
Colin Cross5950f382016-12-13 12:50:57 -0800121 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700122
Colin Cross81413472016-04-11 14:37:39 -0700123 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700124
Dan Willemsenb40aab62016-04-20 14:21:14 -0700125 GeneratedSources []string
126 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900127 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700128
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700129 ReexportGeneratedHeaders []string
130
Colin Crossc465efd2021-06-11 18:00:04 -0700131 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700132
133 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700134 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900135
136 // List of libs that need to be excluded for APEX variant
137 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900138 // List of libs that need to be excluded for non-APEX variant
139 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800140
141 // LLNDK headers for the ABI checker to check LLNDK implementation library.
142 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
143 // The core variant cannot depend on the vendor variant because of the order of CreateVariations.
144 // Instead, the LLNDK implementation depends on the LLNDK header libs.
145 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700146}
147
Ivan Lozano0a468a42024-05-13 21:03:34 -0400148// A struct which to collect flags for rlib dependencies
149type RustRlibDep struct {
150 LibPath android.Path // path to the rlib
151 LinkDirs []string // flags required for dependency (e.g. -L flags)
152 CrateName string // crateNames associated with rlibDeps
153}
154
155func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
156 return a.LibPath == b.LibPath
157}
158
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500159// PathDeps is a struct containing file paths to dependencies of a module.
160// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
161// It's used to construct flags for various build statements (such as for compiling and linking).
162// It is then passed to module decorator functions responsible for registering build statements
163// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800164type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700165 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900166 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700167 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900168 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700169 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700170 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400171 // Paths and crateNames for RustStaticLib dependencies
172 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700173
Colin Cross0de8a1e2020-09-18 14:15:30 -0700174 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossc85750b2022-04-21 12:50:51 -0700175 TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700176
Colin Cross26c34ed2016-09-30 17:10:16 -0700177 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100178 Objs Objects
179 // Paths to .o files in dependencies that provide them. Note that these lists
180 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800181 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700182 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700183
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100184 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
185 // the libs from all whole_static_lib dependencies.
186 WholeStaticLibsFromPrebuilts android.Paths
187
Colin Cross26c34ed2016-09-30 17:10:16 -0700188 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700189 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900190 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700191
Inseob Kimd110f872019-12-06 13:15:38 +0900192 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000193 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900194 IncludeDirs android.Paths
195 SystemIncludeDirs android.Paths
196 ReexportedDirs android.Paths
197 ReexportedSystemDirs android.Paths
198 ReexportedFlags []string
199 ReexportedGeneratedHeaders android.Paths
200 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400201 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700202
Colin Cross26c34ed2016-09-30 17:10:16 -0700203 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700204 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700205
Dan Willemsena0790e32018-10-12 00:24:23 -0700206 // Path to the dynamic linker binary
207 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700208
209 // For Darwin builds, the path to the second architecture's output that should
210 // be combined with this architectures's output into a FAT MachO file.
211 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400212
213 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
214 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800215
216 // LLNDK headers for the ABI checker to check LLNDK implementation library.
217 LlndkIncludeDirs android.Paths
218 LlndkSystemIncludeDirs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700219}
220
Colin Cross4af21ed2019-11-04 09:37:55 -0800221// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
222// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
223// command line so they can be overridden by the local module flags).
224type LocalOrGlobalFlags struct {
225 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700226 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800227 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700228 CFlags []string // Flags that apply to C and C++ source files
229 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
230 ConlyFlags []string // Flags that apply to C source files
231 CppFlags []string // Flags that apply to C++ source files
232 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700233 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800234}
235
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500236// Flags contains various types of command line flags (and settings) for use in building build
237// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800238type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500239 // Local flags (which individual modules are responsible for). These may override global flags.
240 Local LocalOrGlobalFlags
241 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700242 Global LocalOrGlobalFlags
243 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800244
245 aidlFlags []string // Flags that apply to aidl source files
246 rsFlags []string // Flags that apply to renderscript source files
247 libFlags []string // Flags to add libraries early to the link order
248 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
249 TidyFlags []string // Flags that apply to clang-tidy
250 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700251
Colin Crossc3199482017-03-30 15:03:04 -0700252 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800253 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700254 SystemIncludeFlags []string
255
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800256 Toolchain config.Toolchain
257 Tidy bool // True if ninja .tidy rules should be generated.
258 NeedTidyFiles bool // True if module link should depend on .tidy files
259 GcovCoverage bool // True if coverage files should be generated.
260 SAbiDump bool // True if header abi dumps should be generated.
261 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800262 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800263
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500264 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800265 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500266 // The target-device system path to the dynamic linker.
267 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800268
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700269 CFlagsDeps android.Paths // Files depended on by compiler flags
270 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800271
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500272 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700273 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800274
Colin Cross19878da2019-03-28 14:45:07 -0700275 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700276 protoC bool // Whether to use C instead of C++
277 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700278
279 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200280 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700281}
282
Colin Crossca860ac2016-01-04 14:34:37 -0800283// Properties used to compile all C or C++ modules
284type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700285 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800286 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700287
Yi Kong5786f5c2024-05-28 02:22:34 +0900288 // Aggresively trade performance for smaller binary size.
289 // This should only be used for on-device binaries that are rarely executed and not
290 // performance critical.
291 Optimize_for_size *bool `android:"arch_variant"`
292
Jiyong Parkb35a8192020-08-10 15:59:36 +0900293 // The API level that this module is built against. The APIs of this API level will be
294 // visible at build time, but use of any APIs newer than min_sdk_version will render the
295 // module unloadable on older devices. In the future it will be possible to weakly-link new
296 // APIs, making the behavior match Java: such modules will load on older devices, but
297 // calling new APIs on devices that do not support them will result in a crash.
298 //
299 // This property has the same behavior as sdk_version does for Java modules. For those
300 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
301 // does for Java code.
302 //
303 // In addition, setting this property causes two variants to be built, one for the platform
304 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800305 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700306
Jiyong Parkb35a8192020-08-10 15:59:36 +0900307 // Minimum OS API level supported by this C or C++ module. This property becomes the value
308 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
309 // this property is also used to ensure that the min_sdk_version of the containing module is
310 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
311 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
312 // min_sdk_version of the containing APEX. When the module
313 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900314 Min_sdk_version *string
315
Colin Crossc511bc52020-04-07 16:50:32 +0000316 // If true, always create an sdk variant and don't create a platform variant.
317 Sdk_variant_only *bool
318
Jiyong Parkde866cb2018-12-07 23:08:36 +0900319 AndroidMkSharedLibs []string `blueprint:"mutated"`
320 AndroidMkStaticLibs []string `blueprint:"mutated"`
Ivan Lozano0a468a42024-05-13 21:03:34 -0400321 AndroidMkRlibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900322 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
323 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700324 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900325 HideFromMake bool `blueprint:"mutated"`
326 PreventInstall bool `blueprint:"mutated"`
327 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700328
Yo Chiang219968c2020-09-22 18:45:04 +0800329 // Set by DepsMutator.
330 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
331
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900332 // The name of the image this module is built for
333 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200334
335 // The VNDK version this module is built against. If empty, the module is not
336 // build against the VNDK.
337 VndkVersion string `blueprint:"mutated"`
338
339 // Suffix for the name of Android.mk entries generated by this module
340 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800341
342 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
343 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900344 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900345
Yifan Hong39143a92020-10-26 12:43:12 -0700346 // Make this module available when building for ramdisk.
347 // On device without a dedicated recovery partition, the module is only
348 // available after switching root into
349 // /first_stage_ramdisk. To expose the module before switching root, install
350 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800351 Ramdisk_available *bool
352
Yifan Hong39143a92020-10-26 12:43:12 -0700353 // Make this module available when building for vendor ramdisk.
354 // On device without a dedicated recovery partition, the module is only
355 // available after switching root into
356 // /first_stage_ramdisk. To expose the module before switching root, install
357 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700358 Vendor_ramdisk_available *bool
359
Jiyong Parkf9332f12018-02-01 00:54:12 +0900360 // Make this module available when building for recovery
361 Recovery_available *bool
362
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200363 // Used by imageMutator, set by ImageMutatorBegin()
364 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
Ivan Lozano0a468a42024-05-13 21:03:34 -0400747// rlib returns true if the libraryDependencyTag is tagging an rlib dependency.
748func (d libraryDependencyTag) rlib() bool {
749 return d.Kind == rlibLibraryDependency
750}
751
Colin Cross65cb3142021-12-10 23:05:02 +0000752func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
753 if d.shared() {
754 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
755 }
756 return nil
757}
758
759var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
760
Colin Crosse9fe2942020-11-10 18:12:15 -0800761// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
762// binaries or other shared libraries are installed as dependencies.
763func (d libraryDependencyTag) InstallDepNeeded() bool {
764 return d.shared()
765}
766
767var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
768
Yu Liu67a28422024-03-05 00:36:31 +0000769func (d libraryDependencyTag) PropagateAconfigValidation() bool {
770 return d.static()
771}
772
773var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
774
Colin Crosse9fe2942020-11-10 18:12:15 -0800775// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700776// libraryDependencyTag. Each tag object is created globally and reused for multiple
777// dependencies (although since the object contains no references, assigning a tag to a
778// variable and modifying it will not modify the original). Users can compare the tag
779// returned by ctx.OtherModuleDependencyTag against the global original
780type dependencyTag struct {
781 blueprint.BaseDependencyTag
782 name string
783}
784
Colin Crosse9fe2942020-11-10 18:12:15 -0800785// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
786// libraryDependencyTag, but where the dependency needs to be installed when the parent is
787// installed.
788type installDependencyTag struct {
789 blueprint.BaseDependencyTag
790 android.InstallAlwaysNeededDependencyTag
791 name string
792}
793
Colin Crossc99deeb2016-04-11 15:06:20 -0700794var (
Colin Cross6e511a92020-07-27 21:26:48 -0700795 genSourceDepTag = dependencyTag{name: "gen source"}
796 genHeaderDepTag = dependencyTag{name: "gen header"}
797 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
798 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900799 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700800 reuseObjTag = dependencyTag{name: "reuse objects"}
801 staticVariantTag = dependencyTag{name: "static variant"}
802 vndkExtDepTag = dependencyTag{name: "vndk extends"}
803 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700804 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800805 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700806 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700807 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000808 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500809 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400810 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800811 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700812)
813
Roland Levillainf89cd092019-07-29 16:22:59 +0100814func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700815 ccLibDepTag, ok := depTag.(libraryDependencyTag)
816 return ok && ccLibDepTag.shared()
817}
818
819func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
820 ccLibDepTag, ok := depTag.(libraryDependencyTag)
821 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100822}
823
Zach Johnson3df4e632020-11-06 11:56:27 -0800824func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
825 ccLibDepTag, ok := depTag.(libraryDependencyTag)
826 return ok && ccLibDepTag.header()
827}
828
Roland Levillainf89cd092019-07-29 16:22:59 +0100829func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800830 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100831}
832
833func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700834 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100835 return ok && ccDepTag == testPerSrcDepTag
836}
837
Colin Crossca860ac2016-01-04 14:34:37 -0800838// Module contains the properties and members used by all C/C++ module types, and implements
839// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500840// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
841// interface.
842//
843// To define a C/C++ related module, construct a new Module object and point its delegates to
844// type-specific structs. These delegates will be invoked to register module-specific build
845// statements which may be unique to the module type. For example, module.compiler.compile() should
846// be defined so as to register build statements which are responsible for compiling the module.
847//
848// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
849// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
850// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
851// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800852type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700853 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700854
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700855 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700856 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700857 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700858
Colin Crossca860ac2016-01-04 14:34:37 -0800859 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000860 hod android.HostOrDeviceSupported
861 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000862 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700863
Paul Duffina0843f62019-12-13 19:50:38 +0000864 // Allowable SdkMemberTypes of this module type.
865 sdkMemberTypes []android.SdkMemberType
866
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500867 // decorator delegates, initialize before calling Init
868 // these may contain module-specific implementations, and effectively allow for custom
869 // type-specific logic. These members may reference different objects or the same object.
870 // Functions of these decorators will be invoked to initialize and register type-specific
871 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800872 generators []Generator
873 compiler compiler
874 linker linker
875 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500876
Spandan Dase12d2522023-09-12 21:42:31 +0000877 features []feature
878 stl *stl
879 sanitize *sanitize
880 coverage *coverage
881 fuzzer *fuzzer
882 sabi *sabi
Spandan Dase12d2522023-09-12 21:42:31 +0000883 lto *lto
884 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000885 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800886
Colin Cross31076b32020-10-23 17:22:06 -0700887 library libraryInterface
888
Colin Cross635c3b02016-05-18 15:37:25 -0700889 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800890
Colin Crossb98c8b02016-07-29 13:44:28 -0700891 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700892
893 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800894
895 // Flags used to compile this module
896 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700897
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800898 // Shared flags among build rules of this module
899 sharedFlags SharedFlags
900
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800901 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700902 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900903
904 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800905 // Kythe (source file indexer) paths for this compilation module
906 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700907 // Object .o file output paths for this compilation module
908 objFiles android.Paths
909 // Tidy .tidy file output paths for this compilation module
910 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900911
912 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700913 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700914
915 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800916
Inseob Kim37e0bb02024-04-29 15:54:44 +0900917 logtagsPaths android.Paths
Colin Crossc472d572015-03-17 15:06:21 -0700918}
919
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200920func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400921 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
922 if b, ok := c.compiler.(*baseCompiler); ok {
923 hasAidl = b.hasSrcExt(".aidl")
924 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
925 hasProto = b.hasSrcExt(".proto")
926 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
927 hasSysprop = b.hasSrcExt(".sysprop")
928 hasWinMsg = b.hasSrcExt(".mc")
929 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
930 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200931 c.AndroidModuleBase().AddJSONData(d)
932 (*d)["Cc"] = map[string]interface{}{
933 "SdkVersion": c.SdkVersion(),
934 "MinSdkVersion": c.MinSdkVersion(),
935 "VndkVersion": c.VndkVersion(),
936 "ProductSpecific": c.ProductSpecific(),
937 "SocSpecific": c.SocSpecific(),
938 "DeviceSpecific": c.DeviceSpecific(),
939 "InProduct": c.InProduct(),
940 "InVendor": c.InVendor(),
941 "InRamdisk": c.InRamdisk(),
942 "InVendorRamdisk": c.InVendorRamdisk(),
943 "InRecovery": c.InRecovery(),
944 "VendorAvailable": c.VendorAvailable(),
945 "ProductAvailable": c.ProductAvailable(),
946 "RamdiskAvailable": c.RamdiskAvailable(),
947 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
948 "RecoveryAvailable": c.RecoveryAvailable(),
949 "OdmAvailable": c.OdmAvailable(),
950 "InstallInData": c.InstallInData(),
951 "InstallInRamdisk": c.InstallInRamdisk(),
952 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
953 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
954 "InstallInRecovery": c.InstallInRecovery(),
955 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200956 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200957 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
958 "ApexSdkVersion": c.apexSdkVersion,
959 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400960 "AidlSrcs": hasAidl,
961 "LexSrcs": hasLex,
962 "ProtoSrcs": hasProto,
963 "RenderscriptSrcs": hasRenderscript,
964 "SyspropSrcs": hasSysprop,
965 "WinMsgSrcs": hasWinMsg,
966 "YaccSrsc": hasYacc,
967 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900968 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200969 }
970}
971
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500972func (c *Module) SetPreventInstall() {
973 c.Properties.PreventInstall = true
974}
975
976func (c *Module) SetHideFromMake() {
977 c.Properties.HideFromMake = true
978}
979
Ivan Lozanod7586b62021-04-01 09:49:36 -0400980func (c *Module) HiddenFromMake() bool {
981 return c.Properties.HideFromMake
982}
983
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800984func (c *Module) RequiredModuleNames() []string {
985 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
986 if c.ImageVariation().Variation == android.CoreVariation {
987 required = append(required, c.Properties.Target.Platform.Required...)
988 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
989 } else if c.InRecovery() {
990 required = append(required, c.Properties.Target.Recovery.Required...)
991 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
992 }
993 return android.FirstUniqueStrings(required)
994}
995
Ivan Lozano52767be2019-10-18 14:49:46 -0700996func (c *Module) Toc() android.OptionalPath {
997 if c.linker != nil {
998 if library, ok := c.linker.(libraryInterface); ok {
999 return library.toc()
1000 }
1001 }
1002 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
1003}
1004
1005func (c *Module) ApiLevel() string {
1006 if c.linker != nil {
1007 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001008 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001009 }
1010 }
1011 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1012}
1013
1014func (c *Module) Static() bool {
1015 if c.linker != nil {
1016 if library, ok := c.linker.(libraryInterface); ok {
1017 return library.static()
1018 }
1019 }
1020 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1021}
1022
1023func (c *Module) Shared() bool {
1024 if c.linker != nil {
1025 if library, ok := c.linker.(libraryInterface); ok {
1026 return library.shared()
1027 }
1028 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001029
Ivan Lozano52767be2019-10-18 14:49:46 -07001030 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1031}
1032
1033func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001034 if c.stl != nil {
1035 return c.stl.Properties.SelectedStl
1036 }
1037 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001038}
1039
Ivan Lozano52767be2019-10-18 14:49:46 -07001040func (c *Module) NdkPrebuiltStl() bool {
1041 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1042 return true
1043 }
1044 return false
1045}
1046
1047func (c *Module) StubDecorator() bool {
1048 if _, ok := c.linker.(*stubDecorator); ok {
1049 return true
1050 }
1051 return false
1052}
1053
Yi Kong5786f5c2024-05-28 02:22:34 +09001054func (c *Module) OptimizeForSize() bool {
1055 return Bool(c.Properties.Optimize_for_size)
1056}
1057
Ivan Lozano52767be2019-10-18 14:49:46 -07001058func (c *Module) SdkVersion() string {
1059 return String(c.Properties.Sdk_version)
1060}
1061
Artur Satayev480e25b2020-04-27 18:53:18 +01001062func (c *Module) MinSdkVersion() string {
1063 return String(c.Properties.Min_sdk_version)
1064}
1065
Jiyong Park5df7bd32021-08-25 16:18:46 +09001066func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001067 if linker, ok := c.linker.(*objectLinker); ok {
1068 return linker.isCrt()
1069 }
1070 return false
1071}
1072
Jiyong Park5df7bd32021-08-25 16:18:46 +09001073func (c *Module) SplitPerApiLevel() bool {
1074 return c.canUseSdk() && c.isCrt()
1075}
1076
Colin Crossc511bc52020-04-07 16:50:32 +00001077func (c *Module) AlwaysSdk() bool {
1078 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1079}
1080
Ivan Lozano183a3212019-10-18 14:18:45 -07001081func (c *Module) CcLibrary() bool {
1082 if c.linker != nil {
1083 if _, ok := c.linker.(*libraryDecorator); ok {
1084 return true
1085 }
Colin Crossd48fe732020-09-23 20:37:24 -07001086 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1087 return true
1088 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001089 }
1090 return false
1091}
1092
1093func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001094 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001095 return true
1096 }
1097 return false
1098}
1099
Spandan Dase12d2522023-09-12 21:42:31 +00001100func (c *Module) IsNdkPrebuiltStl() bool {
1101 if c.linker == nil {
1102 return false
1103 }
1104 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1105 return true
1106 }
1107 return false
1108}
1109
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001110func (c *Module) RlibStd() bool {
1111 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1112}
1113
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001114func (c *Module) RustLibraryInterface() bool {
1115 return false
1116}
1117
Ivan Lozano0a468a42024-05-13 21:03:34 -04001118func (c *Module) CrateName() string {
1119 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1120}
1121
1122func (c *Module) ExportedCrateLinkDirs() []string {
1123 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1124}
1125
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001126func (c *Module) IsFuzzModule() bool {
1127 if _, ok := c.compiler.(*fuzzBinary); ok {
1128 return true
1129 }
1130 return false
1131}
1132
1133func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1134 return c.FuzzModule
1135}
1136
1137func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1138 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1139 return fuzzer.fuzzPackagedModule
1140 }
1141 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1142}
1143
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001144func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001145 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1146 return fuzzer.sharedLibraries
1147 }
1148 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1149}
1150
Ivan Lozano2b262972019-11-21 12:30:50 -08001151func (c *Module) NonCcVariants() bool {
1152 return false
1153}
1154
Ivan Lozano183a3212019-10-18 14:18:45 -07001155func (c *Module) SetStatic() {
1156 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001157 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001158 library.setStatic()
1159 return
1160 }
1161 }
1162 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1163}
1164
1165func (c *Module) SetShared() {
1166 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001167 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001168 library.setShared()
1169 return
1170 }
1171 }
1172 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1173}
1174
1175func (c *Module) BuildStaticVariant() 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.buildStatic()
1179 }
1180 }
1181 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1182}
1183
1184func (c *Module) BuildSharedVariant() bool {
1185 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001186 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001187 return library.buildShared()
1188 }
1189 }
1190 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1191}
1192
1193func (c *Module) Module() android.Module {
1194 return c
1195}
1196
Jiyong Parkc20eee32018-09-05 22:36:17 +09001197func (c *Module) OutputFile() android.OptionalPath {
1198 return c.outputFile
1199}
1200
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001201func (c *Module) CoverageFiles() android.Paths {
1202 if c.linker != nil {
1203 if library, ok := c.linker.(libraryInterface); ok {
1204 return library.objs().coverageFiles
1205 }
1206 }
1207 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1208}
1209
Ivan Lozano183a3212019-10-18 14:18:45 -07001210var _ LinkableInterface = (*Module)(nil)
1211
Jiyong Park719b4462019-01-13 00:39:51 +09001212func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001213 if c.linker != nil {
1214 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001215 }
1216 return nil
1217}
1218
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001219func (c *Module) CoverageOutputFile() android.OptionalPath {
1220 if c.linker != nil {
1221 return c.linker.coverageOutputFilePath()
1222 }
1223 return android.OptionalPath{}
1224}
1225
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001226func (c *Module) RelativeInstallPath() string {
1227 if c.installer != nil {
1228 return c.installer.relativeInstallPath()
1229 }
1230 return ""
1231}
1232
Jooyung Han344d5432019-08-23 11:17:39 +09001233func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001234 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001235}
1236
Colin Cross36242852017-06-23 15:06:31 -07001237func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001238 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001239 for _, generator := range c.generators {
1240 c.AddProperties(generator.GeneratorProps()...)
1241 }
Colin Crossca860ac2016-01-04 14:34:37 -08001242 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001243 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001244 }
1245 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001246 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001247 }
1248 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001249 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001250 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001251 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001252 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001253 }
Colin Cross16b23492016-01-06 14:41:07 -08001254 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001255 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001256 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001257 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001258 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001259 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001260 if c.fuzzer != nil {
1261 c.AddProperties(c.fuzzer.props()...)
1262 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001263 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001264 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001265 }
Stephen Craneba090d12017-05-09 15:44:35 -07001266 if c.lto != nil {
1267 c.AddProperties(c.lto.props()...)
1268 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001269 if c.afdo != nil {
1270 c.AddProperties(c.afdo.props()...)
1271 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001272 if c.orderfile != nil {
1273 c.AddProperties(c.orderfile.props()...)
1274 }
Colin Crossca860ac2016-01-04 14:34:37 -08001275 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001276 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001277 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001278 // Allow test-only on libraries that are not cc_test_library
1279 if c.library != nil && !c.testLibrary() {
1280 c.AddProperties(&c.sourceProperties)
1281 }
Colin Crossc472d572015-03-17 15:06:21 -07001282
Colin Cross36242852017-06-23 15:06:31 -07001283 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001284 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001285 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001286
Colin Cross36242852017-06-23 15:06:31 -07001287 return c
Colin Crossc472d572015-03-17 15:06:21 -07001288}
1289
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001290// UseVndk() returns true if this module is built against VNDK.
1291// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001292func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001293 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001294}
1295
Colin Crossc511bc52020-04-07 16:50:32 +00001296func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001297 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001298 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001299}
1300
1301func (c *Module) UseSdk() bool {
1302 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001303 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001304 }
1305 return false
1306}
1307
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001308func (c *Module) isCoverageVariant() bool {
1309 return c.coverage.Properties.IsCoverageVariant
1310}
1311
Colin Cross95f1ca02020-10-29 20:47:22 -07001312func (c *Module) IsNdk(config android.Config) bool {
1313 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001314}
1315
Colin Cross127bb8b2020-12-16 16:46:01 -08001316func (c *Module) IsLlndk() bool {
1317 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001318}
1319
Colin Cross1f3f1302021-04-26 18:37:44 -07001320func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001321 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001322 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001323}
1324
Colin Cross5271fea2021-04-27 13:06:04 -07001325func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1326 lib := moduleLibraryInterface(m)
1327 return lib != nil && (lib.hasVendorPublicLibrary())
1328}
1329
1330// IsVendorPublicLibrary returns true for vendor public libraries.
1331func (c *Module) IsVendorPublicLibrary() bool {
1332 return c.VendorProperties.IsVendorPublicLibrary
1333}
1334
Ivan Lozanof1868af2022-04-12 13:08:36 -04001335func (c *Module) IsVndkPrebuiltLibrary() bool {
1336 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1337 return true
1338 }
1339 return false
1340}
1341
1342func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1343 return c.Properties.SdkAndPlatformVariantVisibleToMake
1344}
1345
Ivan Lozanod7586b62021-04-01 09:49:36 -04001346func (c *Module) HasLlndkStubs() bool {
1347 lib := moduleLibraryInterface(c)
1348 return lib != nil && lib.hasLLNDKStubs()
1349}
1350
1351func (c *Module) StubsVersion() string {
1352 if lib, ok := c.linker.(versionedInterface); ok {
1353 return lib.stubsVersion()
1354 }
1355 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1356}
1357
Colin Cross127bb8b2020-12-16 16:46:01 -08001358// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1359// and does not set llndk.vendor_available: false.
1360func (c *Module) isImplementationForLLNDKPublic() bool {
1361 library, _ := c.library.(*libraryDecorator)
1362 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001363 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001364}
1365
Colin Cross3513fb12024-01-24 14:44:47 -08001366func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001367 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001368 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001369 }
1370 return false
1371}
1372
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001373func (c *Module) isOrderfileCompile() bool {
1374 if orderfile := c.orderfile; orderfile != nil {
1375 return orderfile.Properties.OrderfileLoad
1376 }
1377 return false
1378}
1379
Yi Kongc702ebd2022-08-19 16:02:45 +08001380func (c *Module) isCfi() bool {
1381 if sanitize := c.sanitize; sanitize != nil {
Yi Kongddffe722023-07-18 16:40:36 +09001382 return Bool(sanitize.Properties.SanitizeMutated.Cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001383 }
1384 return false
1385}
1386
Yi Konged79fa32023-06-04 17:15:42 +09001387func (c *Module) isFuzzer() bool {
1388 if sanitize := c.sanitize; sanitize != nil {
1389 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1390 }
1391 return false
1392}
1393
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001394func (c *Module) isNDKStubLibrary() bool {
1395 if _, ok := c.compiler.(*stubDecorator); ok {
1396 return true
1397 }
1398 return false
1399}
1400
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001401func (c *Module) SubName() string {
1402 return c.Properties.SubName
1403}
1404
Jiyong Park25fc6a92018-11-18 18:02:45 +09001405func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001406 if lib := c.library; lib != nil {
1407 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001408 }
1409 return false
1410}
1411
1412func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001413 if lib := c.library; lib != nil {
1414 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001415 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001416 return false
1417}
1418
Alan Stokes73feba32022-11-14 12:21:24 +00001419func (c *Module) IsStubsImplementationRequired() bool {
1420 if lib := c.library; lib != nil {
1421 return lib.isStubsImplementationRequired()
1422 }
1423 return false
1424}
1425
Colin Cross0477b422020-10-13 18:43:54 -07001426// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1427// the implementation. If it is an implementation library it returns its own name.
1428func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1429 name := ctx.OtherModuleName(c)
1430 if versioned, ok := c.linker.(versionedInterface); ok {
1431 name = versioned.implementationModuleName(name)
1432 }
1433 return name
1434}
1435
Martin Stjernholm2856c662020-12-02 15:03:42 +00001436// Similar to ImplementationModuleName, but uses the Make variant of the module
1437// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1438// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1439// under the premise that the prebuilt module overrides its source counterpart
1440// if it is exposed to Make).
1441func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1442 name := c.BaseModuleName()
1443 if versioned, ok := c.linker.(versionedInterface); ok {
1444 name = versioned.implementationModuleName(name)
1445 }
1446 return name
1447}
1448
Jiyong Park7d55b612021-06-11 17:22:09 +09001449func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001450 return Bool(c.Properties.Bootstrap)
1451}
1452
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001453func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001454 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1455 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1456 return false
1457 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001458 return c.linker != nil && c.linker.nativeCoverage()
1459}
1460
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001461func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001462 if p, ok := c.linker.(SnapshotInterface); ok {
1463 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001464 }
1465 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001466}
1467
Jiyong Parkf1194352019-02-25 11:05:47 +09001468func isBionic(name string) bool {
1469 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001470 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001471 return true
1472 }
1473 return false
1474}
1475
Martin Stjernholm279de572019-09-10 23:18:20 +01001476func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001477 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001478 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001479 }
1480 return isBionic(name)
1481}
1482
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001483func (c *Module) XrefCcFiles() android.Paths {
1484 return c.kytheFiles
1485}
1486
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001487func (c *Module) isCfiAssemblySupportEnabled() bool {
1488 return c.sanitize != nil &&
1489 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1490}
1491
Inseob Kim800d1142021-06-14 12:03:51 +09001492func (c *Module) InstallInRoot() bool {
1493 return c.installer != nil && c.installer.installInRoot()
1494}
1495
Colin Crossca860ac2016-01-04 14:34:37 -08001496type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001497 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001498 moduleContextImpl
1499}
1500
Colin Cross37047f12016-12-13 17:06:13 -08001501type depsContext struct {
1502 android.BottomUpMutatorContext
1503 moduleContextImpl
1504}
1505
Colin Crossca860ac2016-01-04 14:34:37 -08001506type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001507 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001508 moduleContextImpl
1509}
1510
1511type moduleContextImpl struct {
1512 mod *Module
1513 ctx BaseModuleContext
1514}
1515
Colin Crossb98c8b02016-07-29 13:44:28 -07001516func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001517 return ctx.mod.toolchain(ctx.ctx)
1518}
1519
1520func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001521 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001522}
1523
1524func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001525 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001526}
1527
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001528func (ctx *moduleContextImpl) testBinary() bool {
1529 return ctx.mod.testBinary()
1530}
1531
Yi Kong56fc1b62022-09-06 16:24:00 +08001532func (ctx *moduleContextImpl) testLibrary() bool {
1533 return ctx.mod.testLibrary()
1534}
1535
Jiyong Park1d1119f2019-07-29 21:27:18 +09001536func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001537 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001538}
1539
Inseob Kim7f283f42020-06-01 21:53:49 +09001540func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001541 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001542}
1543
Inseob Kim1042d292020-06-01 23:23:05 +09001544func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001545 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001546}
1547
Yi Kong5786f5c2024-05-28 02:22:34 +09001548func (ctx *moduleContextImpl) optimizeForSize() bool {
1549 return ctx.mod.OptimizeForSize()
1550}
1551
Jooyung Hanccce2f22020-03-07 03:45:53 +09001552func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001553 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001554}
1555
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001556func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001557 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001558}
1559
1560func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001561 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001562 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001563 }
1564 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001565}
1566
Jiyong Parkb35a8192020-08-10 15:59:36 +09001567func (ctx *moduleContextImpl) minSdkVersion() string {
1568 ver := ctx.mod.MinSdkVersion()
1569 if ver == "apex_inherit" && !ctx.isForPlatform() {
1570 ver = ctx.apexSdkVersion().String()
1571 }
1572 if ver == "apex_inherit" || ver == "" {
1573 ver = ctx.sdkVersion()
1574 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001575
1576 if ctx.ctx.Device() {
1577 config := ctx.ctx.Config()
Kiyoung Kim8f05c542024-05-22 16:50:34 +09001578 if ctx.inVendor() {
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001579 // If building for vendor with final API, then use the latest _stable_ API as "current".
1580 if config.VendorApiLevelFrozen() && (ver == "" || ver == "current") {
1581 ver = config.PlatformSdkVersion().String()
1582 }
1583 }
1584 }
1585
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001586 // For crt objects, the meaning of min_sdk_version is very different from other types of
1587 // module. For them, min_sdk_version defines the oldest version that the build system will
1588 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1589 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1590 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001591 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1592 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1593 // support such an old version. The version is set to the later version in case when the
1594 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1595 // it's for an APEX.
1596 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1597 if ctx.isForPlatform() {
1598 ver = strconv.Itoa(android.FutureApiLevelInt)
1599 } else { // for apex
1600 ver = ctx.apexSdkVersion().String()
1601 if ver == "" { // in case when min_sdk_version was not set by the APEX
1602 ver = ctx.sdkVersion()
1603 }
1604 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001605 }
1606
Jiyong Parkb35a8192020-08-10 15:59:36 +09001607 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1608 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1609 minSdkVersionInt, err2 := strconv.Atoi(ver)
1610 if err == nil && err2 == nil {
1611 if sdkVersionInt < minSdkVersionInt {
1612 return strconv.Itoa(sdkVersionInt)
1613 }
1614 }
1615 return ver
1616}
1617
1618func (ctx *moduleContextImpl) isSdkVariant() bool {
1619 return ctx.mod.IsSdkVariant()
1620}
1621
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001622func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001623 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001624}
Justin Yun8effde42017-06-23 19:24:43 +09001625
Kiyoung Kimaa394802024-01-08 12:55:45 +09001626func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1627 return ctx.mod.InVendorOrProduct()
1628}
1629
Colin Cross95f1ca02020-10-29 20:47:22 -07001630func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1631 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001632}
1633
Colin Cross127bb8b2020-12-16 16:46:01 -08001634func (ctx *moduleContextImpl) IsLlndk() bool {
1635 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001636}
1637
Colin Cross127bb8b2020-12-16 16:46:01 -08001638func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1639 return ctx.mod.isImplementationForLLNDKPublic()
1640}
1641
Colin Cross3513fb12024-01-24 14:44:47 -08001642func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1643 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001644}
1645
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001646func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1647 return ctx.mod.isOrderfileCompile()
1648}
1649
Yi Kongc702ebd2022-08-19 16:02:45 +08001650func (ctx *moduleContextImpl) isCfi() bool {
1651 return ctx.mod.isCfi()
1652}
1653
Yi Konged79fa32023-06-04 17:15:42 +09001654func (ctx *moduleContextImpl) isFuzzer() bool {
1655 return ctx.mod.isFuzzer()
1656}
1657
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001658func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1659 return ctx.mod.isNDKStubLibrary()
1660}
1661
Colin Cross5271fea2021-04-27 13:06:04 -07001662func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1663 return ctx.mod.IsVendorPublicLibrary()
1664}
1665
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001666func (ctx *moduleContextImpl) selectedStl() string {
1667 if stl := ctx.mod.stl; stl != nil {
1668 return stl.Properties.SelectedStl
1669 }
1670 return ""
1671}
1672
Ivan Lozanobd721262018-11-27 14:33:03 -08001673func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1674 return ctx.mod.linker.useClangLld(actx)
1675}
1676
Colin Crossce75d2c2016-10-06 16:12:58 -07001677func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001678 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001679}
1680
Logan Chiene274fc92019-12-03 11:18:32 -08001681func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001682 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1683 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001684}
1685
Colin Crosse07f2312020-08-13 11:24:56 -07001686func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001687 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1688 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001689}
1690
Dan Albertc8060532020-07-22 22:32:17 -07001691func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001692 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001693}
1694
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001695func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001696 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001697}
1698
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001699func (ctx *moduleContextImpl) nativeCoverage() bool {
1700 return ctx.mod.nativeCoverage()
1701}
1702
Colin Cross56a83212020-09-15 18:30:11 -07001703func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1704 return ctx.mod.DirectlyInAnyApex()
1705}
1706
Colin Cross95b07f22020-12-16 11:06:50 -08001707func (ctx *moduleContextImpl) isPreventInstall() bool {
1708 return ctx.mod.Properties.PreventInstall
1709}
1710
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001711func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1712 shared := &ctx.mod.sharedFlags
1713 if shared.flagsMap == nil {
1714 shared.numSharedFlags = 0
1715 shared.flagsMap = make(map[string]string)
1716 }
1717 return shared
1718}
1719
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001720func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1721 return ctx.mod.isCfiAssemblySupportEnabled()
1722}
1723
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001724func (ctx *moduleContextImpl) notInPlatform() bool {
1725 return ctx.mod.NotInPlatform()
1726}
1727
Colin Cross635c3b02016-05-18 15:37:25 -07001728func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001729 return &Module{
1730 hod: hod,
1731 multilib: multilib,
1732 }
1733}
1734
Colin Cross635c3b02016-05-18 15:37:25 -07001735func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001736 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001737 module.features = []feature{
1738 &tidyFeature{},
1739 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001740 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001741 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001742 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001743 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001744 module.sabi = &sabi{}
Stephen Craneba090d12017-05-09 15:44:35 -07001745 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001746 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001747 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001748 return module
1749}
1750
Colin Crossce75d2c2016-10-06 16:12:58 -07001751func (c *Module) Prebuilt() *android.Prebuilt {
1752 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1753 return p.prebuilt()
1754 }
1755 return nil
1756}
1757
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001758func (c *Module) IsPrebuilt() bool {
1759 return c.Prebuilt() != nil
1760}
1761
Colin Crossce75d2c2016-10-06 16:12:58 -07001762func (c *Module) Name() string {
1763 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001764 if p, ok := c.linker.(interface {
1765 Name(string) string
1766 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001767 name = p.Name(name)
1768 }
1769 return name
1770}
1771
Alex Light3d673592019-01-18 14:37:31 -08001772func (c *Module) Symlinks() []string {
1773 if p, ok := c.installer.(interface {
1774 symlinkList() []string
1775 }); ok {
1776 return p.symlinkList()
1777 }
1778 return nil
1779}
1780
Roland Levillainf89cd092019-07-29 16:22:59 +01001781func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1782 test, ok := c.linker.(testPerSrc)
1783 return ok && test.isAllTestsVariation()
1784}
1785
Chris Parsons216e10a2020-07-09 17:12:52 -04001786func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001787 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001788 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001789 }); ok {
1790 return p.dataPaths()
1791 }
1792 return nil
1793}
1794
Ivan Lozanof1868af2022-04-12 13:08:36 -04001795func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001796 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1797 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001798 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001799 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001800 if c.ProductSpecific() {
1801 // If the module is product specific with 'product_specific: true',
1802 // do not add a name suffix because it is a base module.
1803 return ""
1804 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001805 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001806 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001807 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001808 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001809 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001810 // add version suffix only if the module is using different vndk version than the
1811 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001812 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001813 }
1814 return nameSuffix
1815}
1816
Ivan Lozanof1868af2022-04-12 13:08:36 -04001817func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1818 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001819
1820 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001821 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001822 }
1823
Colin Cross127bb8b2020-12-16 16:46:01 -08001824 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001825 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001826 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1827 // added for product variant only when we have vendor and product variants with core
1828 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001829 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001830 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001831 subName += vendorPublicLibrarySuffix
1832 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001833 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1834 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001835 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001836 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001837 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001838 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001839 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001840 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001841 subName += RecoverySuffix
1842 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1843 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001844 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001845 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001846 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001847 } else if c.IsStubs() && c.IsSdkVariant() {
1848 // Public API surface (NDK)
1849 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1850 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001851 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001852
1853 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001854}
1855
Sam Delmerico75dbca22023-04-20 13:13:25 +00001856func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1857 ctx := &moduleContext{
1858 ModuleContext: actx,
1859 moduleContextImpl: moduleContextImpl{
1860 mod: c,
1861 },
1862 }
1863 ctx.ctx = ctx
1864 return ctx
1865}
1866
Spandan Das20fce2d2023-04-12 17:21:39 +00001867// TODO (b/277651159): Remove this allowlist
1868var (
1869 skipStubLibraryMultipleApexViolation = map[string]bool{
1870 "libclang_rt.asan": true,
1871 "libclang_rt.hwasan": true,
1872 // runtime apex
1873 "libc": true,
1874 "libc_hwasan": true,
1875 "libdl_android": true,
1876 "libm": true,
1877 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001878 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001879 // art apex
1880 "libandroidio": true,
1881 "libdexfile": true,
1882 "libnativebridge": true,
1883 "libnativehelper": true,
1884 "libnativeloader": true,
1885 "libsigchain": true,
1886 }
1887)
1888
1889// Returns true if a stub library could be installed in multiple apexes
1890func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1891 // If this is not an apex variant, no check necessary
1892 if !c.InAnyApex() {
1893 return false
1894 }
1895 // If this is not a stub library, no check necessary
1896 if !c.HasStubsVariants() {
1897 return false
1898 }
1899 // Skip the allowlist
1900 // Use BaseModuleName so that this matches prebuilts.
1901 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1902 return false
1903 }
1904
1905 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1906 // Stub libraries should not have more than one apex_available
1907 if len(aaWithoutTestApexes) > 1 {
1908 return true
1909 }
1910 // Stub libraries should not use the wildcard
1911 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1912 return true
1913 }
1914 // Default: no violation
1915 return false
1916}
1917
Chris Parsons8d6e4332021-02-22 16:13:50 -05001918func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001919 ctx := moduleContextFromAndroidModuleContext(actx, c)
1920
Inseob Kim37e0bb02024-04-29 15:54:44 +09001921 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
1922 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
1923 Logtags: c.logtagsPaths,
1924 })
1925
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001926 // If Test_only is set on a module in bp file, respect the setting, otherwise
1927 // see if is a known test module type.
1928 testOnly := c.testModule || c.testLibrary()
1929 if c.sourceProperties.Test_only != nil {
1930 testOnly = Bool(c.sourceProperties.Test_only)
1931 }
1932 // Keep before any early returns.
1933 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
1934 TestOnly: testOnly,
1935 TopLevelTarget: c.testModule,
1936 })
1937
Chris Parsons8d6e4332021-02-22 16:13:50 -05001938 // Handle the case of a test module split by `test_per_src` mutator.
1939 //
1940 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1941 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1942 // module and return early, as this module does not produce an output file per se.
1943 if c.IsTestPerSrcAllTestsVariation() {
1944 c.outputFile = android.OptionalPath{}
1945 return
1946 }
1947
Ivan Lozanof1868af2022-04-12 13:08:36 -04001948 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08001949 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001950 if !apexInfo.IsForPlatform() {
1951 c.hideApexVariantFromMake = true
1952 }
1953
Chris Parsonseefc9e62021-04-02 17:36:47 -04001954 c.makeLinkType = GetMakeLinkType(actx, c)
1955
Colin Crossf18e1102017-11-16 14:33:08 -08001956 deps := c.depsToPaths(ctx)
1957 if ctx.Failed() {
1958 return
1959 }
1960
Joe Onorato37f900c2023-07-18 16:58:16 -07001961 for _, generator := range c.generators {
1962 gen := generator.GeneratorSources(ctx)
1963 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
1964 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
1965 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
1966 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
1967 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
1968 if len(deps.Objs.objFiles) == 0 {
1969 // If we are reusuing object files (which happens when we're a shared library and we're
1970 // reusing our static variant's object files), then skip adding the actual source files,
1971 // because we already have the object for it.
1972 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
1973 }
1974 }
1975
1976 if ctx.Failed() {
1977 return
1978 }
1979
Spandan Das20fce2d2023-04-12 17:21:39 +00001980 if c.stubLibraryMultipleApexViolation(actx) {
1981 actx.PropertyErrorf("apex_available",
1982 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
1983 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001984 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1985 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001986 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1987 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001988 }
1989
Colin Crossca860ac2016-01-04 14:34:37 -08001990 flags := Flags{
1991 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001992 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001993 }
Joe Onorato37f900c2023-07-18 16:58:16 -07001994 for _, generator := range c.generators {
1995 flags = generator.GeneratorFlags(ctx, flags, deps)
1996 }
Colin Crossca860ac2016-01-04 14:34:37 -08001997 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001998 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001999 }
2000 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002001 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002002 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002003 if c.stl != nil {
2004 flags = c.stl.flags(ctx, flags)
2005 }
Colin Cross16b23492016-01-06 14:41:07 -08002006 if c.sanitize != nil {
2007 flags = c.sanitize.flags(ctx, flags)
2008 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002009 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002010 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002011 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002012 if c.fuzzer != nil {
2013 flags = c.fuzzer.flags(ctx, flags)
2014 }
Stephen Craneba090d12017-05-09 15:44:35 -07002015 if c.lto != nil {
2016 flags = c.lto.flags(ctx, flags)
2017 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002018 if c.afdo != nil {
2019 flags = c.afdo.flags(ctx, flags)
2020 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002021 if c.orderfile != nil {
2022 flags = c.orderfile.flags(ctx, flags)
2023 }
Colin Crossca860ac2016-01-04 14:34:37 -08002024 for _, feature := range c.features {
2025 flags = feature.flags(ctx, flags)
2026 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002027 if ctx.Failed() {
2028 return
2029 }
2030
Colin Cross4af21ed2019-11-04 09:37:55 -08002031 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2032 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2033 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002034
Colin Cross4af21ed2019-11-04 09:37:55 -08002035 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002036
2037 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002038 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002039 }
2040 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002041 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002042 }
2043
Colin Cross3e5e7782022-06-17 22:17:05 +00002044 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2045
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002046 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002047 // We need access to all the flags seen by a source file.
2048 if c.sabi != nil {
2049 flags = c.sabi.flags(ctx, flags)
2050 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002051
Colin Cross4af21ed2019-11-04 09:37:55 -08002052 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002053
Joe Onorato37f900c2023-07-18 16:58:16 -07002054 for _, generator := range c.generators {
2055 generator.GeneratorBuildActions(ctx, flags, deps)
2056 }
2057
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002058 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002059 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002060 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002061 if ctx.Failed() {
2062 return
2063 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002064 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002065 c.objFiles = objs.objFiles
2066 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002067 }
2068
Colin Crossca860ac2016-01-04 14:34:37 -08002069 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002070 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002071 if ctx.Failed() {
2072 return
2073 }
Colin Cross635c3b02016-05-18 15:37:25 -07002074 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002075
Chris Parsons94a0bba2021-06-04 15:03:47 -04002076 c.maybeUnhideFromMake()
Colin Crossce75d2c2016-10-06 16:12:58 -07002077 }
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002078 if c.testModule {
Colin Cross40213022023-12-13 15:19:49 -08002079 android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{})
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002080 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002081
Colin Cross40213022023-12-13 15:19:49 -08002082 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002083
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002084 if Bool(c.Properties.Cmake_snapshot_supported) {
2085 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2086 }
2087
Chris Parsons94a0bba2021-06-04 15:03:47 -04002088 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002089
2090 if c.linker != nil {
2091 moduleInfoJSON := ctx.ModuleInfoJSON()
2092 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2093 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2094 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2095 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2096 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2097
2098 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2099 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2100 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2101 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2102
2103 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2104 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2105 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2106 moduleInfoJSON.SubName += ".cfi"
2107 }
2108 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2109 moduleInfoJSON.SubName += ".hwasan"
2110 }
2111 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2112 moduleInfoJSON.SubName += ".scs"
2113 }
2114 }
2115 moduleInfoJSON.SubName += c.Properties.SubName
2116
2117 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2118 moduleInfoJSON.Uninstallable = true
2119 }
2120
2121 }
Chris Parsons94a0bba2021-06-04 15:03:47 -04002122}
2123
2124func (c *Module) maybeUnhideFromMake() {
2125 // If a lib is directly included in any of the APEXes or is not available to the
2126 // platform (which is often the case when the stub is provided as a prebuilt),
2127 // unhide the stubs variant having the latest version gets visible to make. In
2128 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2129 // force anything in the make world to link against the stubs library. (unless it
2130 // is explicitly referenced via .bootstrap suffix or the module is marked with
2131 // 'bootstrap: true').
2132 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002133 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002134 c.IsStubs() && !c.InVendorRamdisk() {
2135 c.Properties.HideFromMake = false // unhide
2136 // Note: this is still non-installable
2137 }
2138}
2139
Colin Cross8ff10582023-12-07 13:10:56 -08002140// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2141// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002142func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002143 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002144 // If the module has been specifically configure to not be installed then
2145 // hide from make as otherwise it will break when running inside make
2146 // as the output path to install will not be specified. Not all uninstallable
2147 // modules can be hidden from make as some are needed for resolving make side
2148 // dependencies.
2149 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002150 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002151 c.SkipInstall()
2152 }
2153
2154 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2155 // to allow using the outputs in a genrule.
2156 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002157 c.installer.install(ctx, c.outputFile.Path())
2158 if ctx.Failed() {
2159 return
Colin Crossca860ac2016-01-04 14:34:37 -08002160 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002161 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002162}
2163
Colin Cross0ea8ba82019-06-06 14:33:29 -07002164func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002165 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002166 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002167 }
Colin Crossca860ac2016-01-04 14:34:37 -08002168 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002169}
2170
Colin Crossca860ac2016-01-04 14:34:37 -08002171func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002172 for _, generator := range c.generators {
2173 generator.GeneratorInit(ctx)
2174 }
Colin Crossca860ac2016-01-04 14:34:37 -08002175 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002176 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002177 }
Colin Crossca860ac2016-01-04 14:34:37 -08002178 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002179 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002180 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002181 if c.stl != nil {
2182 c.stl.begin(ctx)
2183 }
Colin Cross16b23492016-01-06 14:41:07 -08002184 if c.sanitize != nil {
2185 c.sanitize.begin(ctx)
2186 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002187 if c.coverage != nil {
2188 c.coverage.begin(ctx)
2189 }
Yi Kong9723e332023-12-04 14:52:53 +09002190 if c.afdo != nil {
2191 c.afdo.begin(ctx)
2192 }
Stephen Craneba090d12017-05-09 15:44:35 -07002193 if c.lto != nil {
2194 c.lto.begin(ctx)
2195 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002196 if c.orderfile != nil {
2197 c.orderfile.begin(ctx)
2198 }
Dan Albert92fe7402020-07-15 13:33:30 -07002199 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002200 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002201 if err != nil {
2202 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002203 c.Properties.Sdk_version = nil
2204 } else {
2205 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002206 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002207 }
Colin Crossca860ac2016-01-04 14:34:37 -08002208}
2209
Colin Cross37047f12016-12-13 17:06:13 -08002210func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002211 deps := Deps{}
2212
Joe Onorato37f900c2023-07-18 16:58:16 -07002213 for _, generator := range c.generators {
2214 deps = generator.GeneratorDeps(ctx, deps)
2215 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002216 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002217 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002218 }
2219 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002220 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002221 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002222 if c.stl != nil {
2223 deps = c.stl.deps(ctx, deps)
2224 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002225 if c.coverage != nil {
2226 deps = c.coverage.deps(ctx, deps)
2227 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002228
Colin Crossb6715442017-10-24 11:13:31 -07002229 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2230 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
Ivan Lozano0a468a42024-05-13 21:03:34 -04002231 deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
Colin Crossb6715442017-10-24 11:13:31 -07002232 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2233 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2234 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2235 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002236 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002237 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002238
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002239 for _, lib := range deps.ReexportSharedLibHeaders {
2240 if !inList(lib, deps.SharedLibs) {
2241 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2242 }
2243 }
2244
2245 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002246 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2247 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 -07002248 }
2249 }
2250
Colin Cross5950f382016-12-13 12:50:57 -08002251 for _, lib := range deps.ReexportHeaderLibHeaders {
2252 if !inList(lib, deps.HeaderLibs) {
2253 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2254 }
2255 }
2256
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002257 for _, gen := range deps.ReexportGeneratedHeaders {
2258 if !inList(gen, deps.GeneratedHeaders) {
2259 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2260 }
2261 }
2262
Colin Crossc99deeb2016-04-11 15:06:20 -07002263 return deps
2264}
2265
Dan Albert7e9d2952016-08-04 13:02:36 -07002266func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002267 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002268 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002269 moduleContextImpl: moduleContextImpl{
2270 mod: c,
2271 },
2272 }
2273 ctx.ctx = ctx
2274
Colin Crossca860ac2016-01-04 14:34:37 -08002275 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002276}
2277
Jiyong Park7ed9de32018-10-15 22:25:07 +09002278// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002279func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002280 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2281 version := name[sharp+1:]
2282 libname := name[:sharp]
2283 return libname, version
2284 }
2285 return name, ""
2286}
2287
Dan Albert92fe7402020-07-15 13:33:30 -07002288func GetCrtVariations(ctx android.BottomUpMutatorContext,
2289 m LinkableInterface) []blueprint.Variation {
2290 if ctx.Os() != android.Android {
2291 return nil
2292 }
2293 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002294 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2295 minSdkVersion := m.MinSdkVersion()
2296 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2297 minSdkVersion = m.SdkVersion()
2298 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002299 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2300 if err != nil {
2301 ctx.PropertyErrorf("min_sdk_version", err.Error())
2302 }
Colin Cross363ec762023-01-13 13:45:14 -08002303
2304 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002305 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002306 if apiLevel.LessThan(minApiForArch) {
2307 apiLevel = minApiForArch
2308 }
2309
Dan Albert92fe7402020-07-15 13:33:30 -07002310 return []blueprint.Variation{
2311 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002312 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002313 }
2314 }
2315 return []blueprint.Variation{
2316 {Mutator: "sdk", Variation: ""},
2317 }
2318}
2319
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002320func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2321 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002322
2323 variations = append([]blueprint.Variation(nil), variations...)
2324
Liz Kammer23942242022-04-08 15:41:00 -04002325 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002326 // Version is explicitly specified. i.e. libFoo#30
2327 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002328 if tag, ok := depTag.(libraryDependencyTag); ok {
2329 tag.explicitlyVersioned = true
2330 } else {
2331 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2332 }
Colin Crosse7257d22020-09-24 09:56:18 -07002333 }
Colin Crosse7257d22020-09-24 09:56:18 -07002334
Colin Cross0de8a1e2020-09-18 14:15:30 -07002335 if far {
2336 ctx.AddFarVariationDependencies(variations, depTag, name)
2337 } else {
2338 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002339 }
2340}
2341
Kiyoung Kim487689e2022-07-26 09:48:22 +09002342func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2343 apiImportInfo := multitree.ApiImportInfo{}
2344
2345 if c.Device() {
2346 var apiImportModule []blueprint.Module
2347 if actx.OtherModuleExists("api_imports") {
2348 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2349 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
Colin Cross313aa542023-12-13 13:47:44 -08002350 apiInfo, _ := android.OtherModuleProvider(actx, apiImportModule[0], multitree.ApiImportsProvider)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002351 apiImportInfo = apiInfo
Colin Cross40213022023-12-13 15:19:49 -08002352 android.SetProvider(actx, multitree.ApiImportsProvider, apiInfo)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002353 }
2354 }
2355 }
2356
2357 return apiImportInfo
2358}
2359
Kiyoung Kim487689e2022-07-26 09:48:22 +09002360func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2361 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002362 return snapshot
2363 }
2364
2365 return lib
2366}
2367
Kiyoung Kim37693d02024-04-04 09:56:15 +09002368// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002369// of names:
2370//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002371// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002372//
2373// For each of these, it adds the name of the ndk_library module to the list of
2374// variant libs.
2375//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002376// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002377//
2378// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002379//
2380// The caller can then know to add the variantLibs dependencies differently from the
2381// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002382func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002383 variantLibs = []string{}
2384
2385 nonvariantLibs = []string{}
2386 for _, entry := range list {
2387 // strip #version suffix out
2388 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002389 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002390 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002391 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002392 nonvariantLibs = append(nonvariantLibs, entry)
2393 }
2394 }
2395 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002396
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002397}
2398
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002399func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2400 nonVariantLibs := []string{}
2401 variantLibs := []string{}
2402
2403 for _, lib := range libs {
2404 replaceLibName := GetReplaceModuleName(lib, replaceList)
2405 if replaceLibName == lib {
2406 // Do not handle any libs which are not in API imports
2407 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2408 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2409 variantLibs = append(variantLibs, replaceLibName)
2410 } else {
2411 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2412 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002413 }
2414
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002415 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002416}
2417
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002418func (c *Module) shouldUseApiSurface() bool {
2419 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2420 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2421 // LLNDK Variant
2422 return true
2423 }
2424
2425 if c.Properties.IsSdkVariant {
2426 // NDK Variant
2427 return true
2428 }
2429
2430 if c.isImportedApiLibrary() {
2431 // API Library should depend on API headers
2432 return true
2433 }
2434 }
2435
2436 return false
2437}
2438
Colin Cross1e676be2016-10-12 14:38:15 -07002439func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002440 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002441 return
2442 }
2443
Colin Cross37047f12016-12-13 17:06:13 -08002444 ctx := &depsContext{
2445 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002446 moduleContextImpl: moduleContextImpl{
2447 mod: c,
2448 },
2449 }
2450 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002451
Colin Crossc99deeb2016-04-11 15:06:20 -07002452 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002453 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002454
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002455 apiNdkLibs := []string{}
2456 apiLateNdkLibs := []string{}
2457
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002458 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002459 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2460 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2461 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2462 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2463 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002464 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002465
Yo Chiang219968c2020-09-22 18:45:04 +08002466 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2467
Dan Albert914449f2016-06-17 16:45:24 -07002468 variantNdkLibs := []string{}
2469 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002470 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002471 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2472 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2473 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002474 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002475
Colin Cross32ec36c2016-12-15 07:39:51 -08002476 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002477 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002478 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002479 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002480 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002481
Kiyoung Kim51279d32022-08-24 14:10:46 +09002482 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002483 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002484 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2485 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002486
Spandan Das73bcafc2022-08-18 23:26:00 +00002487 if c.isNDKStubLibrary() {
2488 // ndk_headers do not have any variations
2489 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002490 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002491 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002492 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002493 } else {
2494 actx.AddVariationDependencies(nil, depTag, lib)
2495 }
2496 }
2497
Dan Albertf1d14c72020-07-30 14:32:55 -07002498 if c.isNDKStubLibrary() {
2499 // NDK stubs depend on their implementation because the ABI dumps are
2500 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002501
Spandan Das8b08aea2023-03-14 19:29:34 +00002502 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2503 c.ImageVariation(),
2504 blueprint.Variation{Mutator: "link", Variation: "shared"},
2505 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002506 }
2507
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002508 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2509 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2510 c.Target().NativeBridge == android.NativeBridgeDisabled {
2511 actx.AddVariationDependencies(
2512 []blueprint.Variation{{Mutator: "image", Variation: VendorVariation}},
2513 llndkHeaderLibTag,
2514 deps.LlndkHeaderLibs...)
2515 }
2516
Jiyong Park5d1598f2019-02-25 22:14:17 +09002517 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002518 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002519
Jiyong Park5d1598f2019-02-25 22:14:17 +09002520 actx.AddVariationDependencies([]blueprint.Variation{
2521 {Mutator: "link", Variation: "static"},
2522 }, depTag, lib)
2523 }
2524
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002525 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002526 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002527 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002528 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002529 }
Jiyong Parke3867542020-12-03 17:28:25 +09002530 if inList(lib, deps.ExcludeLibsForApex) {
2531 depTag.excludeInApex = true
2532 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002533
Dan Willemsen59339a22018-07-22 21:18:45 -07002534 actx.AddVariationDependencies([]blueprint.Variation{
2535 {Mutator: "link", Variation: "static"},
2536 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002537 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002538
Ivan Lozano0a468a42024-05-13 21:03:34 -04002539 for _, lib := range deps.Rlibs {
2540 depTag := libraryDependencyTag{Kind: rlibLibraryDependency}
2541 actx.AddVariationDependencies([]blueprint.Variation{
2542 {Mutator: "link", Variation: ""},
2543 {Mutator: "rust_libraries", Variation: "rlib"},
2544 {Mutator: "rust_stdlinkage", Variation: "rlib-std"},
2545 }, depTag, lib)
2546 }
2547
Jooyung Han75568392020-03-20 04:29:24 +09002548 // staticUnwinderDep is treated as staticDep for Q apexes
2549 // so that native libraries/binaries are linked with static unwinder
2550 // because Q libc doesn't have unwinder APIs
2551 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002552 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002553 actx.AddVariationDependencies([]blueprint.Variation{
2554 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002555 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002556 }
2557
Jiyong Park7ed9de32018-10-15 22:25:07 +09002558 // shared lib names without the #version suffix
2559 var sharedLibNames []string
2560
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002561 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002562 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002563 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002564 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002565 }
Jiyong Parke3867542020-12-03 17:28:25 +09002566 if inList(lib, deps.ExcludeLibsForApex) {
2567 depTag.excludeInApex = true
2568 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002569 if inList(lib, deps.ExcludeLibsForNonApex) {
2570 depTag.excludeInNonApex = true
2571 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002572
Jiyong Park73c54ee2019-10-22 20:31:18 +09002573 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002574 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2575 name = apiLibraryName
2576 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002577 sharedLibNames = append(sharedLibNames, name)
2578
Colin Crosse7257d22020-09-24 09:56:18 -07002579 variations := []blueprint.Variation{
2580 {Mutator: "link", Variation: "shared"},
2581 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002582
2583 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2584 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2585 }
2586
2587 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2588 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2589 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002590 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002591
Colin Crossfe9acfe2021-06-14 16:13:03 -07002592 for _, lib := range deps.LateStaticLibs {
2593 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2594 actx.AddVariationDependencies([]blueprint.Variation{
2595 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002596 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002597 }
2598
Colin Cross3e5e7782022-06-17 22:17:05 +00002599 for _, lib := range deps.UnexportedStaticLibs {
2600 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2601 actx.AddVariationDependencies([]blueprint.Variation{
2602 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002603 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002604 }
2605
Jiyong Park7ed9de32018-10-15 22:25:07 +09002606 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002607 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002608 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2609 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2610 // linking against both the stubs lib and the non-stubs lib at the same time.
2611 continue
2612 }
Colin Cross6e511a92020-07-27 21:26:48 -07002613 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002614 variations := []blueprint.Variation{
2615 {Mutator: "link", Variation: "shared"},
2616 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002617 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002618 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002619
Dan Willemsen59339a22018-07-22 21:18:45 -07002620 actx.AddVariationDependencies([]blueprint.Variation{
2621 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002622 }, dataLibDepTag, deps.DataLibs...)
2623
Colin Crossc8caa062021-09-24 16:50:14 -07002624 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2625
Chris Parsons79d66a52020-06-05 17:26:16 -04002626 actx.AddVariationDependencies([]blueprint.Variation{
2627 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002628 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002629
Colin Cross68861832016-07-08 10:41:41 -07002630 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002631
2632 for _, gen := range deps.GeneratedHeaders {
2633 depTag := genHeaderDepTag
2634 if inList(gen, deps.ReexportGeneratedHeaders) {
2635 depTag = genHeaderExportDepTag
2636 }
2637 actx.AddDependency(c, depTag, gen)
2638 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002639
Dan Albert92fe7402020-07-15 13:33:30 -07002640 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002641 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002642 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002643 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002644 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002645 }
Colin Crossc465efd2021-06-11 18:00:04 -07002646 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002647 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002648 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002649 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002650 if deps.DynamicLinker != "" {
2651 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002652 }
Dan Albert914449f2016-06-17 16:45:24 -07002653
2654 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002655
2656 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002657 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002658 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002659 {Mutator: "link", Variation: "shared"},
2660 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002661 actx.AddVariationDependencies([]blueprint.Variation{
2662 {Mutator: "version", Variation: version},
2663 {Mutator: "link", Variation: "shared"},
2664 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002665
2666 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002667 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002668 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002669 {Mutator: "link", Variation: "shared"},
2670 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002671 actx.AddVariationDependencies([]blueprint.Variation{
2672 {Mutator: "version", Variation: version},
2673 {Mutator: "link", Variation: "shared"},
2674 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002675
Vinh Tran367d89d2023-04-28 11:21:25 -04002676 if len(deps.AidlLibs) > 0 {
2677 actx.AddDependency(
2678 c,
2679 aidlLibraryTag,
2680 deps.AidlLibs...,
2681 )
2682 }
2683
Kiyoung Kimee58c932022-10-25 22:59:41 +09002684 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002685}
Colin Cross21b9a242015-03-24 14:15:58 -07002686
Colin Crosse40b4ea2018-10-02 22:25:58 -07002687func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002688 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002689 c.beginMutator(ctx)
2690 }
2691}
2692
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002693// Whether a module can link to another module, taking into
2694// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002695func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002696 tag blueprint.DependencyTag) {
2697
2698 switch t := tag.(type) {
2699 case dependencyTag:
2700 if t != vndkExtDepTag {
2701 return
2702 }
2703 case libraryDependencyTag:
2704 default:
2705 return
2706 }
2707
Ivan Lozanof9e21722020-12-02 09:00:51 -05002708 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002709 // Host code is not restricted
2710 return
2711 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002712
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002713 // TODO(b/244244438) : Remove this once all variants are implemented
2714 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2715 return
2716 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002717 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002718 // Platform code can link to anything
2719 return
2720 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002721 if from.InRamdisk() {
2722 // Ramdisk code is not NDK
2723 return
2724 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002725 if from.InVendorRamdisk() {
2726 // Vendor ramdisk code is not NDK
2727 return
2728 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002729 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002730 // Recovery code is not NDK
2731 return
2732 }
Colin Cross31076b32020-10-23 17:22:06 -07002733 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002734 if c.NdkPrebuiltStl() {
2735 // These are allowed, but they don't set sdk_version
2736 return
2737 }
2738 if c.StubDecorator() {
2739 // These aren't real libraries, but are the stub shared libraries that are included in
2740 // the NDK.
2741 return
2742 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002743 if c.isImportedApiLibrary() {
2744 // Imported library from the API surface is a stub library built against interface definition.
2745 return
2746 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002747 }
Logan Chien834b9a62019-01-14 15:39:03 +08002748
Ivan Lozano52767be2019-10-18 14:49:46 -07002749 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002750 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2751 // to link to libc++ (non-NDK and without sdk_version).
2752 return
2753 }
2754
Ivan Lozano52767be2019-10-18 14:49:46 -07002755 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002756 // NDK code linking to platform code is never okay.
2757 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002758 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002759 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002760 }
2761
2762 // At this point we know we have two NDK libraries, but we need to
2763 // check that we're not linking against anything built against a higher
2764 // API level, as it is only valid to link against older or equivalent
2765 // APIs.
2766
Inseob Kim01a28722018-04-11 09:48:45 +09002767 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002768 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002769 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002770 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002771 // Current can't be linked against by anything else.
2772 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002773 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002774 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002775 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002776 if err != nil {
2777 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002778 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002779 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002780 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002781 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002782 if err != nil {
2783 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002784 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002785 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002786 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002787
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002788 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002789 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002790 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002791 }
2792 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002793 }
Dan Albert202fe492017-12-15 13:56:59 -08002794
2795 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002796 fromStl := from.SelectedStl()
2797 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002798 if fromStl == "" || toStl == "" {
2799 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002800 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002801 // We can be permissive with the system "STL" since it is only the C++
2802 // ABI layer, but in the future we should make sure that everyone is
2803 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002804 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002805 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002806 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2807 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002808 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002809}
2810
Jooyung Han479ca172020-10-19 18:51:07 +09002811func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2812 if c, ok := ctx.Module().(*Module); ok {
2813 ctx.VisitDirectDeps(func(dep android.Module) {
2814 depTag := ctx.OtherModuleDependencyTag(dep)
2815 ccDep, ok := dep.(LinkableInterface)
2816 if ok {
2817 checkLinkType(ctx, c, ccDep, depTag)
2818 }
2819 })
2820 }
2821}
2822
Jiyong Park5fb8c102018-04-09 12:03:06 +09002823// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002824// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2825// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002826// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002827func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2828 check := func(child, parent android.Module) bool {
2829 to, ok := child.(*Module)
2830 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002831 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002832 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002833
Jooyung Hana70f0672019-01-18 15:20:43 +09002834 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2835 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002836 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002837
Jiyong Park0474e1f2021-01-14 14:26:06 +09002838 // These dependencies are not excercised at runtime. Tracking these will give us
2839 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002840 depTag := ctx.OtherModuleDependencyTag(child)
2841 if IsHeaderDepTag(depTag) {
2842 return false
2843 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002844 if depTag == staticVariantTag {
2845 return false
2846 }
2847 if depTag == stubImplDepTag {
2848 return false
2849 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002850 if depTag == android.RequiredDepTag {
2851 return false
2852 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002853
Justin Yun63e9ec72020-10-29 16:49:43 +09002854 // Even if target lib has no vendor variant, keep checking dependency
2855 // graph in case it depends on vendor_available or product_available
2856 // but not double_loadable transtively.
2857 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002858 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002859 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002860
Jiyong Park0474e1f2021-01-14 14:26:06 +09002861 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2862 // one.
2863 if Bool(to.VendorProperties.Double_loadable) {
2864 return true
2865 }
2866
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002867 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002868 return false
2869 }
2870
Jooyung Hana70f0672019-01-18 15:20:43 +09002871 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2872 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002873 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002874 return false
2875 }
2876 if module, ok := ctx.Module().(*Module); ok {
2877 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002878 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002879 ctx.WalkDeps(check)
2880 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002881 }
2882 }
2883}
2884
Yu Liue4312402023-01-18 09:15:31 -08002885func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2886 // For the dependency from platform to apex, use the latest stubs
2887 apexSdkVersion := android.FutureApiLevel
2888 if !apexInfo.IsForPlatform() {
2889 apexSdkVersion = apexInfo.MinSdkVersion
2890 }
2891
2892 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2893 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2894 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2895 // (b/144430859)
2896 apexSdkVersion = android.FutureApiLevel
2897 }
2898
2899 return apexSdkVersion
2900}
2901
Colin Crossc99deeb2016-04-11 15:06:20 -07002902// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002903func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002904 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002905
Colin Cross0de8a1e2020-09-18 14:15:30 -07002906 var directStaticDeps []StaticLibraryInfo
2907 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002908
Colin Cross0de8a1e2020-09-18 14:15:30 -07002909 reexportExporter := func(exporter FlagExporterInfo) {
2910 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2911 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2912 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2913 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2914 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002915 }
2916
Colin Crossff694a82023-12-13 15:54:49 -08002917 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002918 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002919
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002920 skipModuleList := map[string]bool{}
2921
2922 var apiImportInfo multitree.ApiImportInfo
2923 hasApiImportInfo := false
2924
2925 ctx.VisitDirectDeps(func(dep android.Module) {
2926 if dep.Name() == "api_imports" {
Colin Cross313aa542023-12-13 13:47:44 -08002927 apiImportInfo, _ = android.OtherModuleProvider(ctx, dep, multitree.ApiImportsProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002928 hasApiImportInfo = true
2929 }
2930 })
2931
2932 if hasApiImportInfo {
2933 targetStubModuleList := map[string]string{}
2934 targetOrigModuleList := map[string]string{}
2935
2936 // Search for dependency which both original module and API imported library with APEX stub exists
2937 ctx.VisitDirectDeps(func(dep android.Module) {
2938 depName := ctx.OtherModuleName(dep)
2939 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
2940 targetStubModuleList[apiLibrary] = depName
2941 }
2942 })
2943 ctx.VisitDirectDeps(func(dep android.Module) {
2944 depName := ctx.OtherModuleName(dep)
2945 if origLibrary, ok := targetStubModuleList[depName]; ok {
2946 targetOrigModuleList[origLibrary] = depName
2947 }
2948 })
2949
2950 // Decide which library should be used between original and API imported library
2951 ctx.VisitDirectDeps(func(dep android.Module) {
2952 depName := ctx.OtherModuleName(dep)
2953 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00002954 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002955 skipModuleList[depName] = true
2956 } else {
2957 skipModuleList[apiLibrary] = true
2958 }
2959 }
2960 })
2961 }
2962
Colin Crossd11fcda2017-10-23 17:59:01 -07002963 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002964 depName := ctx.OtherModuleName(dep)
2965 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002966
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002967 if _, ok := skipModuleList[depName]; ok {
2968 // skip this module because original module or API imported module matching with this should be used instead.
2969 return
2970 }
2971
Dan Willemsen47450072021-10-19 20:24:49 -07002972 if depTag == android.DarwinUniversalVariantTag {
2973 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2974 return
2975 }
2976
Vinh Tran367d89d2023-04-28 11:21:25 -04002977 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08002978 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04002979 depPaths.AidlLibraryInfos = append(
2980 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08002981 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04002982 )
2983 }
2984 }
2985
Ivan Lozano52767be2019-10-18 14:49:46 -07002986 ccDep, ok := dep.(LinkableInterface)
2987 if !ok {
2988
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002989 // handling for a few module types that aren't cc Module but that are also supported
2990 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002991 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002992 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002993 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2994 genRule.GeneratedSourceFiles()...)
2995 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002996 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002997 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002998 // Support exported headers from a generated_sources dependency
2999 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003000 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003001 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003002 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003003 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003004 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003005 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003006 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003007 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003008 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3009 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003010 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003011 // 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 +09003012 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003013
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003014 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003015 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003016 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003017 }
Colin Crosscef792e2021-06-11 18:01:26 -07003018 case CrtBeginDepTag:
3019 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3020 case CrtEndDepTag:
3021 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003022 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003023 return
3024 }
3025
Colin Crossfe17f6f2019-03-28 19:30:56 -07003026 if depTag == android.ProtoPluginDepTag {
3027 return
3028 }
3029
Jiyong Park8bcf3c62024-03-18 18:37:10 +09003030 if depTag == android.RequiredDepTag {
3031 return
3032 }
3033
Colin Crossd11fcda2017-10-23 17:59:01 -07003034 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003035 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3036 return
3037 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003038 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003039 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3040 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003041 return
3042 }
3043
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003044 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003045 // Skip reused objects for stub libraries, they use their own stub object file instead.
3046 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3047 // version mutator, so the stubs variant is created from the shared variant that
3048 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003049 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003050 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003051 objs := staticAnalogue.ReuseObjects
3052 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003053 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003054 reexportExporter(depExporterInfo)
3055 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003056 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003057 }
3058
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08003059 if depTag == llndkHeaderLibTag {
3060 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3061 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
3062 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3063 }
3064
Colin Cross6e511a92020-07-27 21:26:48 -07003065 linkFile := ccDep.OutputFile()
3066
3067 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3068 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003069 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003070 return
3071 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003072
Jiyong Parke3867542020-12-03 17:28:25 +09003073 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3074 return
3075 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003076 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3077 return
3078 }
Jiyong Parke3867542020-12-03 17:28:25 +09003079
Colin Cross313aa542023-12-13 13:47:44 -08003080 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003081
Colin Cross6e511a92020-07-27 21:26:48 -07003082 var ptr *android.Paths
3083 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003084
Colin Cross6e511a92020-07-27 21:26:48 -07003085 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003086
Colin Cross6e511a92020-07-27 21:26:48 -07003087 switch {
3088 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003089 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003090 if !ctx.Config().AllowMissingDependencies() {
3091 ctx.ModuleErrorf("module %q is not a header library", depName)
3092 } else {
3093 ctx.AddMissingDependencies([]string{depName})
3094 }
3095 return
3096 }
Colin Cross6e511a92020-07-27 21:26:48 -07003097 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003098 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003099 if !ctx.Config().AllowMissingDependencies() {
3100 ctx.ModuleErrorf("module %q is not a shared library", depName)
3101 } else {
3102 ctx.AddMissingDependencies([]string{depName})
3103 }
3104 return
3105 }
Jiyong Parke3867542020-12-03 17:28:25 +09003106
Jiyong Park7d55b612021-06-11 17:22:09 +09003107 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3108 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003109
Jiyong Park1ad8e162020-12-01 23:40:09 +09003110 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3111 // linkFile, depFile, and ptr.
3112 if c.IsStubs() {
3113 break
3114 }
3115
Colin Cross0de8a1e2020-09-18 14:15:30 -07003116 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3117 depFile = sharedLibraryInfo.TableOfContents
3118
Colin Cross6e511a92020-07-27 21:26:48 -07003119 ptr = &depPaths.SharedLibs
3120 switch libDepTag.Order {
3121 case earlyLibraryDependency:
3122 ptr = &depPaths.EarlySharedLibs
3123 depPtr = &depPaths.EarlySharedLibsDeps
3124 case normalLibraryDependency:
3125 ptr = &depPaths.SharedLibs
3126 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003127 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003128 case lateLibraryDependency:
3129 ptr = &depPaths.LateSharedLibs
3130 depPtr = &depPaths.LateSharedLibsDeps
3131 default:
3132 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003133 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003134
3135 case libDepTag.rlib():
3136 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3137 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
3138 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3139 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3140 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3141
Colin Cross6e511a92020-07-27 21:26:48 -07003142 case libDepTag.static():
Colin Cross313aa542023-12-13 13:47:44 -08003143 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3144 if !isStaticLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003145 if !ctx.Config().AllowMissingDependencies() {
3146 ctx.ModuleErrorf("module %q is not a static library", depName)
3147 } else {
3148 ctx.AddMissingDependencies([]string{depName})
3149 }
3150 return
3151 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003152
3153 // Stubs lib doesn't link to the static lib dependencies. Don't set
3154 // linkFile, depFile, and ptr.
3155 if c.IsStubs() {
3156 break
3157 }
3158
Colin Cross0de8a1e2020-09-18 14:15:30 -07003159 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003160 if libDepTag.wholeStatic {
3161 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003162 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3163 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003164 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003165 // This case normally catches prebuilt static
3166 // libraries, but it can also occur when
3167 // AllowMissingDependencies is on and the
3168 // dependencies has no sources of its own
3169 // but has a whole_static_libs dependency
3170 // on a missing library. We want to depend
3171 // on the .a file so that there is something
3172 // in the dependency tree that contains the
3173 // error rule for the missing transitive
3174 // dependency.
3175 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003176 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003177 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3178 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003179 } else {
3180 switch libDepTag.Order {
3181 case earlyLibraryDependency:
3182 panic(fmt.Errorf("early static libs not suppported"))
3183 case normalLibraryDependency:
3184 // static dependencies will be handled separately so they can be ordered
3185 // using transitive dependencies.
3186 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003187 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003188 case lateLibraryDependency:
3189 ptr = &depPaths.LateStaticLibs
3190 default:
3191 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003192 }
3193 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003194
3195 // We re-export the Rust static_rlibs so rlib dependencies don't need to be redeclared by cc_library_static dependents.
3196 // E.g. libfoo (cc_library_static) depends on libfoo.ffi (a rust_ffi rlib), libbar depending on libfoo shouldn't have to also add libfoo.ffi to static_rlibs.
3197 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3198 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3199
Colin Cross3e5e7782022-06-17 22:17:05 +00003200 if libDepTag.unexportedSymbols {
3201 depPaths.LdFlags = append(depPaths.LdFlags,
3202 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3203 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003204 }
3205
Colin Cross6e511a92020-07-27 21:26:48 -07003206 if libDepTag.static() && !libDepTag.wholeStatic {
3207 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3208 ctx.ModuleErrorf("module %q not a static library", depName)
3209 return
3210 }
Logan Chien43d34c32017-12-20 01:17:32 +08003211
Colin Cross6e511a92020-07-27 21:26:48 -07003212 // When combining coverage files for shared libraries and executables, coverage files
3213 // in static libraries act as if they were whole static libraries. The same goes for
3214 // source based Abi dump files.
3215 if c, ok := ccDep.(*Module); ok {
3216 staticLib := c.linker.(libraryInterface)
3217 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3218 staticLib.objs().coverageFiles...)
3219 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3220 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003221 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003222 // Handle non-CC modules here
3223 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003224 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003225 }
3226 }
3227
Colin Cross6e511a92020-07-27 21:26:48 -07003228 if ptr != nil {
3229 if !linkFile.Valid() {
3230 if !ctx.Config().AllowMissingDependencies() {
3231 ctx.ModuleErrorf("module %q missing output file", depName)
3232 } else {
3233 ctx.AddMissingDependencies([]string{depName})
3234 }
3235 return
3236 }
3237 *ptr = append(*ptr, linkFile.Path())
3238 }
3239
3240 if depPtr != nil {
3241 dep := depFile
3242 if !dep.Valid() {
3243 dep = linkFile
3244 }
3245 *depPtr = append(*depPtr, dep.Path())
3246 }
3247
Colin Cross0de8a1e2020-09-18 14:15:30 -07003248 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3249 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3250 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3251 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003252 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3253
3254 // Only re-export RustRlibDeps for cc static libs
3255 if c.static() {
3256 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3257 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003258
3259 if libDepTag.reexportFlags {
3260 reexportExporter(depExporterInfo)
3261 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3262 // Re-exported shared library headers must be included as well since they can help us with type information
3263 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003264 c.sabi.Properties.ReexportedIncludes = append(
3265 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003266 c.sabi.Properties.ReexportedSystemIncludes = append(
3267 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003268 }
3269
Spandan Das3faa7922024-02-26 19:42:32 +00003270 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003271 switch {
3272 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003273 c.Properties.AndroidMkHeaderLibs = append(
3274 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003275 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003276 if lib := moduleLibraryInterface(dep); lib != nil {
3277 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003278 // Add the dependency to the APEX(es) providing the library so that
3279 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003280 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003281 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003282 c.Properties.ApexesProvidingSharedLibs = append(
3283 c.Properties.ApexesProvidingSharedLibs, an)
3284 }
3285 }
3286 }
3287
3288 // Note: the order of libs in this list is not important because
3289 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003290 c.Properties.AndroidMkSharedLibs = append(
3291 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003292 case libDepTag.static():
3293 if libDepTag.wholeStatic {
3294 c.Properties.AndroidMkWholeStaticLibs = append(
3295 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3296 } else {
3297 c.Properties.AndroidMkStaticLibs = append(
3298 c.Properties.AndroidMkStaticLibs, makeLibName)
3299 }
3300 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003301 } else if !c.IsStubs() {
3302 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3303
Colin Cross6e511a92020-07-27 21:26:48 -07003304 switch depTag {
3305 case runtimeDepTag:
3306 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003307 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003308 case objDepTag:
3309 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3310 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003311 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003312 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003313 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003314 case dynamicLinkerDepTag:
3315 depPaths.DynamicLinker = linkFile
3316 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003317 }
Colin Crossca860ac2016-01-04 14:34:37 -08003318 })
3319
Jeff Gaston294356f2017-09-27 17:05:30 -07003320 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003321 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3322 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3323 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003324
Colin Crossdd84e052017-05-17 13:44:16 -07003325 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003326 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003327 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3328 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003329 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003330 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3331
Jiyong Park74955042019-10-22 20:19:51 +09003332 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3333 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003334 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003335 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003336 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003337 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003338
3339 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003340 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003341 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003342 }
Colin Crossdd84e052017-05-17 13:44:16 -07003343
Colin Crossca860ac2016-01-04 14:34:37 -08003344 return depPaths
3345}
3346
Spandan Das604f3762023-03-16 22:51:40 +00003347func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003348 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003349 thisModule, ok := ctx.Module().(android.ApexModule)
3350 if !ok {
3351 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3352 }
3353
Kiyoung Kimaa394802024-01-08 12:55:45 +09003354 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003355 bootstrap := false
3356 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3357 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3358 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003359 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003360 bootstrap = linkable.Bootstrap()
3361 }
3362
Colin Crossff694a82023-12-13 15:54:49 -08003363 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003364
3365 useStubs := false
3366
Kiyoung Kimaa394802024-01-08 12:55:45 +09003367 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003368 if !apexInfo.IsForPlatform() {
3369 // For platform libraries, use current version of LLNDK
3370 // If this is for use_vendor apex we will apply the same rules
3371 // of apex sdk enforcement below to choose right version.
3372 useStubs = true
3373 }
3374 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3375 // If not building for APEX or the containing APEX allows the use of
3376 // platform APIs, use stubs only when it is from an APEX (and not from
3377 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3378 // bootstrap modules, always link to non-stub variant
3379 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3380
3381 isApexImportedApiLibrary := false
3382
3383 if cc, ok := dep.(*Module); ok {
3384 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3385 if apiLibrary.hasApexStubs() {
3386 isApexImportedApiLibrary = true
3387 }
3388 }
3389 }
3390
3391 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3392
3393 if useStubs {
3394 // Another exception: if this module is a test for an APEX, then
3395 // it is linked with the non-stub variant of a module in the APEX
3396 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003397 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003398 for _, apexContents := range testFor.ApexContents {
3399 if apexContents.DirectlyInApex(depName) {
3400 useStubs = false
3401 break
3402 }
3403 }
3404 }
3405 if useStubs {
3406 // Yet another exception: If this module and the dependency are
3407 // available to the same APEXes then skip stubs between their
3408 // platform variants. This complements the test_for case above,
3409 // which avoids the stubs on a direct APEX library dependency, by
3410 // avoiding stubs for indirect test dependencies as well.
3411 //
3412 // TODO(b/183882457): This doesn't work if the two libraries have
3413 // only partially overlapping apex_available. For that test_for
3414 // modules would need to be split into APEX variants and resolved
3415 // separately for each APEX they have access to.
3416 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3417 useStubs = false
3418 }
3419 }
3420 } else {
3421 // If building for APEX, use stubs when the parent is in any APEX that
3422 // the child is not in.
3423 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3424 }
3425
3426 return useStubs
3427}
3428
3429// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3430// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3431// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3432// has different level of updatability. For example, if a library foo in an APEX depends on a
3433// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3434// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3435// same APEX as foo, the non-stub variant of bar is used.
3436func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3437 depTag := ctx.OtherModuleDependencyTag(dep)
3438 libDepTag, ok := depTag.(libraryDependencyTag)
3439 if !ok || !libDepTag.shared() {
3440 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3441 }
3442
Colin Cross313aa542023-12-13 13:47:44 -08003443 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3444 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3445 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003446
3447 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003448 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003449 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003450 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3451 toUse := stubs[len(stubs)-1]
3452 sharedLibraryInfo = toUse.SharedLibraryInfo
3453 depExporterInfo = toUse.FlagExporterInfo
3454 }
3455 }
3456 return sharedLibraryInfo, depExporterInfo
3457}
3458
Colin Cross0de8a1e2020-09-18 14:15:30 -07003459// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3460// to match the topological order of the dependency tree, including any static analogues of
3461// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3462// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003463func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3464 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003465 var staticPaths android.Paths
3466 for _, staticDep := range staticDeps {
3467 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3468 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3469 }
3470 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003471 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3472 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003473 }
3474 }
3475 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3476
3477 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3478
3479 // reorder the dependencies based on transitive dependencies
3480 staticPaths = android.FirstUniquePaths(staticPaths)
3481 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3482
3483 if len(orderedStaticPaths) != len(staticPaths) {
3484 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3485 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3486 }
3487
3488 return orderedStaticPaths, transitiveStaticLibs
3489}
3490
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003491// BaseLibName trims known prefixes and suffixes
3492func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003493 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3494 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003495 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003496 return libName
3497}
3498
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003499func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003500 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003501 ccDepModule, _ := ccDep.(*Module)
3502 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003503 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003504
Justin Yuncbca3732021-02-03 19:24:13 +09003505 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003506 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003507 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003508 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003509
Ivan Lozanod1dec542021-05-26 15:33:11 -04003510 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003511 }
3512 }
3513
Kiyoung Kim22152f62024-05-24 10:45:28 +09003514 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003515 // The vendor and product modules in Make will have been renamed to not conflict with the
3516 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003517 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003518 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003519 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003520 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003521 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003522 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003523 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003524 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003525 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003526 } else {
3527 return libName
3528 }
3529}
3530
Colin Crossca860ac2016-01-04 14:34:37 -08003531func (c *Module) InstallInData() bool {
3532 if c.installer == nil {
3533 return false
3534 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003535 return c.installer.inData()
3536}
3537
3538func (c *Module) InstallInSanitizerDir() bool {
3539 if c.installer == nil {
3540 return false
3541 }
3542 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003543 return true
3544 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003545 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003546}
3547
Yifan Hong1b3348d2020-01-21 15:53:22 -08003548func (c *Module) InstallInRamdisk() bool {
3549 return c.InRamdisk()
3550}
3551
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003552func (c *Module) InstallInVendorRamdisk() bool {
3553 return c.InVendorRamdisk()
3554}
3555
Jiyong Parkf9332f12018-02-01 00:54:12 +09003556func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003557 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003558}
3559
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003560func (c *Module) MakeUninstallable() {
3561 if c.installer == nil {
3562 c.ModuleBase.MakeUninstallable()
3563 return
3564 }
3565 c.installer.makeUninstallable(c)
3566}
3567
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003568func (c *Module) HostToolPath() android.OptionalPath {
3569 if c.installer == nil {
3570 return android.OptionalPath{}
3571 }
3572 return c.installer.hostToolPath()
3573}
3574
Nan Zhangd4e641b2017-07-12 12:55:28 -07003575func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3576 return c.outputFile
3577}
3578
Colin Cross41955e82019-05-29 14:40:35 -07003579func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3580 switch tag {
3581 case "":
3582 if c.outputFile.Valid() {
3583 return android.Paths{c.outputFile.Path()}, nil
3584 }
3585 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003586 case "unstripped":
3587 if c.linker != nil {
3588 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3589 }
3590 return nil, nil
Wei Li5f5d2712023-12-11 15:40:29 -08003591 case "stripped_all":
3592 if c.linker != nil {
3593 return android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), nil
3594 }
3595 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003596 default:
3597 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003598 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003599}
3600
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003601func (c *Module) static() bool {
3602 if static, ok := c.linker.(interface {
3603 static() bool
3604 }); ok {
3605 return static.static()
3606 }
3607 return false
3608}
3609
Jiyong Park379de2f2018-12-19 02:47:14 +09003610func (c *Module) staticBinary() bool {
3611 if static, ok := c.linker.(interface {
3612 staticBinary() bool
3613 }); ok {
3614 return static.staticBinary()
3615 }
3616 return false
3617}
3618
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003619func (c *Module) testBinary() bool {
3620 if test, ok := c.linker.(interface {
3621 testBinary() bool
3622 }); ok {
3623 return test.testBinary()
3624 }
3625 return false
3626}
3627
Jingwen Chen537242c2022-08-24 11:53:27 +00003628func (c *Module) testLibrary() bool {
3629 if test, ok := c.linker.(interface {
3630 testLibrary() bool
3631 }); ok {
3632 return test.testLibrary()
3633 }
3634 return false
3635}
3636
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003637func (c *Module) benchmarkBinary() bool {
3638 if b, ok := c.linker.(interface {
3639 benchmarkBinary() bool
3640 }); ok {
3641 return b.benchmarkBinary()
3642 }
3643 return false
3644}
3645
3646func (c *Module) fuzzBinary() bool {
3647 if f, ok := c.linker.(interface {
3648 fuzzBinary() bool
3649 }); ok {
3650 return f.fuzzBinary()
3651 }
3652 return false
3653}
3654
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003655// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3656func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003657 if h, ok := c.linker.(interface {
3658 header() bool
3659 }); ok {
3660 return h.header()
3661 }
3662 return false
3663}
3664
Ivan Lozanod7586b62021-04-01 09:49:36 -04003665func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003666 if b, ok := c.linker.(interface {
3667 binary() bool
3668 }); ok {
3669 return b.binary()
3670 }
3671 return false
3672}
3673
Justin Yun5e035862021-06-29 20:50:37 +09003674func (c *Module) StaticExecutable() bool {
3675 if b, ok := c.linker.(*binaryDecorator); ok {
3676 return b.static()
3677 }
3678 return false
3679}
3680
Ivan Lozanod7586b62021-04-01 09:49:36 -04003681func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003682 if o, ok := c.linker.(interface {
3683 object() bool
3684 }); ok {
3685 return o.object()
3686 }
3687 return false
3688}
3689
Kiyoung Kim37693d02024-04-04 09:56:15 +09003690func (m *Module) Dylib() bool {
3691 return false
3692}
3693
3694func (m *Module) Rlib() bool {
3695 return false
3696}
3697
Ivan Lozanof9e21722020-12-02 09:00:51 -05003698func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003699 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003700 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003701 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003702 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003703 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003704 return "native:product"
3705 }
Jooyung Han38002912019-05-16 04:01:54 +09003706 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003707 } else if c.InRamdisk() {
3708 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003709 } else if c.InVendorRamdisk() {
3710 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003711 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003712 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003713 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003714 return "native:ndk:none:none"
3715 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3716 //family, link := getNdkStlFamilyAndLinkType(c)
3717 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3718 } else {
3719 return "native:platform"
3720 }
3721}
3722
Jiyong Park9d452992018-10-03 00:38:19 +09003723// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003724// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003725func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003726 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003727 // Stub libs and prebuilt libs in a versioned SDK are not
3728 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003729 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003730 } else if _, ok := c.linker.(testPerSrc); ok {
3731 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003732 }
3733 return false
3734}
3735
Jiyong Parka90ca002019-10-07 15:47:24 +09003736func (c *Module) AvailableFor(what string) bool {
3737 if linker, ok := c.linker.(interface {
3738 availableFor(string) bool
3739 }); ok {
3740 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3741 } else {
3742 return c.ApexModuleBase.AvailableFor(what)
3743 }
3744}
3745
Jiyong Park62304bb2020-04-13 16:19:48 +09003746func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003747 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003748}
3749
Paul Duffin0cb37b92020-03-04 14:52:46 +00003750func (c *Module) EverInstallable() bool {
3751 return c.installer != nil &&
3752 // Check to see whether the module is actually ever installable.
3753 c.installer.everInstallable()
3754}
3755
Ivan Lozanod7586b62021-04-01 09:49:36 -04003756func (c *Module) PreventInstall() bool {
3757 return c.Properties.PreventInstall
3758}
3759
3760func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003761 if c.library != nil {
3762 if i := c.library.installable(); i != nil {
3763 return i
3764 }
3765 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003766 return c.Properties.Installable
3767}
3768
3769func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003770 ret := c.EverInstallable() &&
3771 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003772 proptools.BoolDefault(c.Installable(), true) &&
3773 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003774
3775 // The platform variant doesn't need further condition. Apex variants however might not
3776 // be installable because it will likely to be included in the APEX and won't appear
3777 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003778 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003779 return ret
3780 }
3781
3782 // Special case for modules that are configured to be installed to /data, which includes
3783 // test modules. For these modules, both APEX and non-APEX variants are considered as
3784 // installable. This is because even the APEX variants won't be included in the APEX, but
3785 // will anyway be installed to /data/*.
3786 // See b/146995717
3787 if c.InstallInData() {
3788 return ret
3789 }
3790
3791 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003792}
3793
Logan Chien41eabe62019-04-10 13:33:58 +08003794func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3795 if c.linker != nil {
3796 if library, ok := c.linker.(*libraryDecorator); ok {
3797 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3798 }
3799 }
3800}
3801
Jiyong Park45bf82e2020-12-15 22:29:02 +09003802var _ android.ApexModule = (*Module)(nil)
3803
3804// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003805func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003806 depTag := ctx.OtherModuleDependencyTag(dep)
3807 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3808
3809 if cc, ok := dep.(*Module); ok {
3810 if cc.HasStubsVariants() {
3811 if isLibDepTag && libDepTag.shared() {
3812 // dynamic dep to a stubs lib crosses APEX boundary
3813 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003814 }
Colin Cross6e511a92020-07-27 21:26:48 -07003815 if IsRuntimeDepTag(depTag) {
3816 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003817 return false
3818 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003819 }
Zhijun Heec285872021-04-24 10:47:08 -07003820 if cc.IsLlndk() {
3821 return false
3822 }
Colin Crossaac32222020-07-29 12:51:56 -07003823 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003824 // shared_lib dependency from a static lib is considered as crossing
3825 // the APEX boundary because the dependency doesn't actually is
3826 // linked; the dependency is used only during the compilation phase.
3827 return false
3828 }
Jiyong Parke3867542020-12-03 17:28:25 +09003829
3830 if isLibDepTag && libDepTag.excludeInApex {
3831 return false
3832 }
Colin Cross6e511a92020-07-27 21:26:48 -07003833 }
Colin Crossc1b36442021-05-06 13:42:48 -07003834 if depTag == stubImplDepTag {
3835 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003836 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003837 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003838 if depTag == staticVariantTag {
3839 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3840 // actually mean that the static lib (and its dependencies) are copied into the
3841 // APEX.
3842 return false
3843 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003844 return true
3845}
3846
Jiyong Park45bf82e2020-12-15 22:29:02 +09003847// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003848func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3849 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003850 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3851 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3852 return nil
3853 }
Jooyung Han749dc692020-04-15 11:03:39 +09003854 // We don't check for prebuilt modules
3855 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3856 return nil
3857 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003858
Jooyung Han749dc692020-04-15 11:03:39 +09003859 minSdkVersion := c.MinSdkVersion()
3860 if minSdkVersion == "apex_inherit" {
3861 return nil
3862 }
3863 if minSdkVersion == "" {
3864 // JNI libs within APK-in-APEX fall into here
3865 // Those are okay to set sdk_version instead
3866 // We don't have to check if this is a SDK variant because
3867 // non-SDK variant resets sdk_version, which works too.
3868 minSdkVersion = c.SdkVersion()
3869 }
Dan Albertc8060532020-07-22 22:32:17 -07003870 if minSdkVersion == "" {
3871 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3872 }
3873 // Not using nativeApiLevelFromUser because the context here is not
3874 // necessarily a native context.
3875 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003876 if err != nil {
3877 return err
3878 }
Dan Albertc8060532020-07-22 22:32:17 -07003879
Colin Cross8ca61c12022-10-06 21:00:14 -07003880 // A dependency only needs to support a min_sdk_version at least
3881 // as high as the api level that the architecture was introduced in.
3882 // This allows introducing new architectures in the platform that
3883 // need to be included in apexes that normally require an older
3884 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003885 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003886 if sdkVersion.LessThan(minApiForArch) {
3887 sdkVersion = minApiForArch
3888 }
3889
Dan Albertc8060532020-07-22 22:32:17 -07003890 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003891 return fmt.Errorf("newer SDK(%v)", ver)
3892 }
3893 return nil
3894}
3895
Paul Duffinb5769c12021-05-12 16:16:51 +01003896// Implements android.ApexModule
3897func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3898 // stub libraries and native bridge libraries are always available to platform
3899 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3900}
3901
Inseob Kima1888ce2022-10-04 14:42:02 +09003902func (c *Module) overriddenModules() []string {
3903 if o, ok := c.linker.(overridable); ok {
3904 return o.overriddenModules()
3905 }
3906 return nil
3907}
3908
Liz Kammer35ca77e2021-12-22 15:31:40 -05003909type moduleType int
3910
3911const (
3912 unknownType moduleType = iota
3913 binary
3914 object
3915 fullLibrary
3916 staticLibrary
3917 sharedLibrary
3918 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003919 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003920 ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00003921 ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05003922)
3923
3924func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003925 if c.testBinary() {
3926 // testBinary is also a binary, so this comes before the c.Binary()
3927 // conditional. A testBinary has additional implicit dependencies and
3928 // other test-only semantics.
3929 return testBin
3930 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003931 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003932 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003933 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003934 } else if c.testLibrary() {
3935 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3936 // will let them add implicit compile deps on gtest, for example.
3937 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003938 // For now, treat them as regular libraries.
3939 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003940 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003941 static := false
3942 shared := false
3943 if library, ok := c.linker.(*libraryDecorator); ok {
3944 static = library.MutatedProperties.BuildStatic
3945 shared = library.MutatedProperties.BuildShared
3946 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3947 static = library.MutatedProperties.BuildStatic
3948 shared = library.MutatedProperties.BuildShared
3949 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003950 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003951 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003952 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003953 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003954 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003955 return staticLibrary
3956 }
3957 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003958 } else if c.isNDKStubLibrary() {
3959 return ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00003960 } else if c.IsNdkPrebuiltStl() {
3961 return ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05003962 }
3963 return unknownType
3964}
3965
Colin Crosscfad1192015-11-02 16:43:11 -08003966// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003967type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003968 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003969 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003970 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003971}
3972
Patrice Arrudac249c712019-03-19 17:00:29 -07003973// cc_defaults provides a set of properties that can be inherited by other cc
3974// modules. A module can use the properties from a cc_defaults using
3975// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3976// merged (when possible) by prepending the default module's values to the
3977// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003978func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003979 return DefaultsFactory()
3980}
3981
Colin Cross36242852017-06-23 15:06:31 -07003982func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003983 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003984
Colin Cross36242852017-06-23 15:06:31 -07003985 module.AddProperties(props...)
3986 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003987 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003988 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003989 &BaseCompilerProperties{},
3990 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003991 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003992 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003993 &StaticProperties{},
3994 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003995 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003996 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003997 &TestLinkerProperties{},
3998 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003999 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004000 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004001 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004002 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004003 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004004 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004005 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004006 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004007 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004008 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004009 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004010 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00004011 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004012 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004013 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4014 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004015 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004016 )
Colin Crosscfad1192015-11-02 16:43:11 -08004017
Jooyung Hancc372c52019-09-25 15:18:44 +09004018 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004019
4020 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004021}
4022
Jiyong Park2286afd2020-06-16 21:58:53 +09004023func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004024 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004025}
4026
Kiyoung Kim51279d32022-08-24 14:10:46 +09004027func (c *Module) isImportedApiLibrary() bool {
4028 _, ok := c.linker.(*apiLibraryDecorator)
4029 return ok
4030}
4031
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004032func kytheExtractAllFactory() android.Singleton {
4033 return &kytheExtractAllSingleton{}
4034}
4035
4036type kytheExtractAllSingleton struct {
4037}
4038
4039func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4040 var xrefTargets android.Paths
4041 ctx.VisitAllModules(func(module android.Module) {
4042 if ccModule, ok := module.(xref); ok {
4043 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4044 }
4045 })
4046 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4047 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004048 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004049 }
4050}
4051
Jihoon Kangf78a8902022-09-01 22:47:07 +00004052func (c *Module) Partition() string {
4053 if p, ok := c.installer.(interface {
4054 getPartition() string
4055 }); ok {
4056 return p.getPartition()
4057 }
4058 return ""
4059}
4060
Spandan Das2b6dfb52024-01-19 00:22:22 +00004061type sourceModuleName interface {
4062 sourceModuleName() string
4063}
4064
4065func (c *Module) BaseModuleName() string {
4066 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
4067 // if the prebuilt module sets a source_module_name in Android.bp, use that
4068 return smn.sourceModuleName()
4069 }
4070 return c.ModuleBase.BaseModuleName()
4071}
4072
Colin Cross06a931b2015-10-28 17:23:31 -07004073var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004074var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004075var BoolPtr = proptools.BoolPtr
4076var String = proptools.String
4077var StringPtr = proptools.StringPtr