blob: 5dee32e48fd37a9cd7456d6b91f106244631a90d [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
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Crossa14fb6a2024-10-23 16:57:06 -070028 "github.com/google/blueprint/depset"
Colin Cross06a931b2015-10-28 17:23:31 -070029 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070030
Vinh Tran367d89d2023-04-28 11:21:25 -040031 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070032 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070033 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070034 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070035 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080036)
37
Yu Liu76d94462024-10-31 23:32:36 +000038type CcMakeVarsInfo struct {
39 WarningsAllowed string
40 UsingWnoError string
41 MissingProfile string
42}
43
44var CcMakeVarsInfoProvider = blueprint.NewProvider[*CcMakeVarsInfo]()
45
Colin Cross463a90e2015-06-17 14:20:06 -070046func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000047 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070048
Inseob Kim3b244062023-07-11 13:31:36 +090049 pctx.Import("android/soong/android")
Paul Duffin036e7002019-12-19 19:16:28 +000050 pctx.Import("android/soong/cc/config")
51}
52
53func RegisterCCBuildComponents(ctx android.RegistrationContext) {
54 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
55
56 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossac57a6c2024-06-26 13:09:53 -070057 ctx.Transition("sdk", &sdkTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070058 ctx.BottomUp("llndk", llndkMutator)
Colin Cross767819f2024-05-22 14:22:34 -070059 ctx.Transition("link", &linkageTransitionMutator{})
Colin Crossadd04a82024-05-22 09:57:59 -070060 ctx.Transition("version", &versionTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070061 ctx.BottomUp("begin", BeginMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070062 })
Colin Cross16b23492016-01-06 14:41:07 -080063
Paul Duffin036e7002019-12-19 19:16:28 +000064 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040065 for _, san := range Sanitizers {
66 san.registerMutators(ctx)
67 }
Dan Willemsen581341d2017-02-09 16:16:31 -080068
Colin Cross8a962802024-10-09 15:29:27 -070069 ctx.BottomUp("sanitize_runtime_deps", sanitizerRuntimeDepsMutator)
70 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator)
Ivan Lozano30c5db22018-02-21 15:49:20 -080071
Colin Cross597bad62024-10-08 15:10:55 -070072 ctx.Transition("fuzz", &fuzzTransitionMutator{})
Cory Barkera1da26f2022-06-07 20:12:06 +000073
Colin Crossf5f4ad32024-01-19 15:41:48 -080074 ctx.Transition("coverage", &coverageTransitionMutator{})
Stephen Craneba090d12017-05-09 15:44:35 -070075
Colin Crossd38feb02024-01-23 16:38:06 -080076 ctx.Transition("afdo", &afdoTransitionMutator{})
Yi Kongeb8efc92021-12-09 18:06:29 +080077
Colin Cross33e0c812024-01-23 16:36:07 -080078 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000079
Colin Cross6ac83a82024-01-23 11:23:10 -080080 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +090081
Colin Cross8a962802024-10-09 15:29:27 -070082 ctx.BottomUp("check_linktype", checkLinkTypeMutator)
83 ctx.BottomUp("double_loadable", checkDoubleLoadableLibraries)
Colin Cross1e676be2016-10-12 14:38:15 -070084 })
Colin Crossb98c8b02016-07-29 13:44:28 -070085
Colin Cross91ae5ec2024-10-01 14:03:40 -070086 ctx.PostApexMutators(func(ctx android.RegisterMutatorsContext) {
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080087 // sabi mutator needs to be run after apex mutator finishes.
Colin Cross91ae5ec2024-10-01 14:03:40 -070088 ctx.Transition("sabi", &sabiTransitionMutator{})
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080089 })
90
LaMont Jones0c10e4d2023-05-16 00:58:37 +000091 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070092}
93
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050094// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
95// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
96// edges to these modules.
97// This object is constructed in DepsMutator, by calling to various module delegates to set
98// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
99// dependencies.
100// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
101// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -0800102type Deps struct {
103 SharedLibs, LateSharedLibs []string
104 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800105 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800106 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700107
Colin Cross3e5e7782022-06-17 22:17:05 +0000108 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
109 // prevent automatically exporting symbols.
110 UnexportedStaticLibs []string
111
Chris Parsons79d66a52020-06-05 17:26:16 -0400112 // Used for data dependencies adjacent to tests
113 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700114 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400115
Yo Chiang219968c2020-09-22 18:45:04 +0800116 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
117 SystemSharedLibs []string
118
Vinh Tran367d89d2023-04-28 11:21:25 -0400119 // Used by DepMutator to pass aidl_library modules to aidl compiler
120 AidlLibs []string
121
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500122 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800123 StaticUnwinderIfLegacy bool
124
Colin Cross5950f382016-12-13 12:50:57 -0800125 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700126
Colin Cross81413472016-04-11 14:37:39 -0700127 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700128
Cole Faust65cb40a2024-10-21 15:41:42 -0700129 GeneratedSources []string
130 GeneratedHeaders []string
131 DeviceFirstGeneratedHeaders []string
132 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700133
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700134 ReexportGeneratedHeaders []string
135
Colin Crossc465efd2021-06-11 18:00:04 -0700136 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700137
138 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700139 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900140
141 // List of libs that need to be excluded for APEX variant
142 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900143 // List of libs that need to be excluded for non-APEX variant
144 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800145
146 // LLNDK headers for the ABI checker to check LLNDK implementation library.
147 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
Colin Cross1e954b62024-09-13 13:50:00 -0700148 // The core variant cannot depend on the vendor variant because of the order of imageTransitionMutator.Split().
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800149 // Instead, the LLNDK implementation depends on the LLNDK header libs.
150 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700151}
152
Ivan Lozano0a468a42024-05-13 21:03:34 -0400153// A struct which to collect flags for rlib dependencies
154type RustRlibDep struct {
155 LibPath android.Path // path to the rlib
156 LinkDirs []string // flags required for dependency (e.g. -L flags)
157 CrateName string // crateNames associated with rlibDeps
158}
159
160func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
161 return a.LibPath == b.LibPath
162}
163
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500164// PathDeps is a struct containing file paths to dependencies of a module.
165// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
166// It's used to construct flags for various build statements (such as for compiling and linking).
167// It is then passed to module decorator functions responsible for registering build statements
168// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800169type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700170 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900171 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700172 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900173 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700174 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700175 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400176 // Paths and crateNames for RustStaticLib dependencies
177 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700178
Colin Cross0de8a1e2020-09-18 14:15:30 -0700179 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossa14fb6a2024-10-23 16:57:06 -0700180 TranstiveStaticLibrariesForOrdering depset.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700181
Colin Cross26c34ed2016-09-30 17:10:16 -0700182 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100183 Objs Objects
184 // Paths to .o files in dependencies that provide them. Note that these lists
185 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800186 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700187 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700188
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100189 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
190 // the libs from all whole_static_lib dependencies.
191 WholeStaticLibsFromPrebuilts android.Paths
192
Colin Cross26c34ed2016-09-30 17:10:16 -0700193 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700194 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900195 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700196
Inseob Kimd110f872019-12-06 13:15:38 +0900197 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000198 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900199 IncludeDirs android.Paths
200 SystemIncludeDirs android.Paths
201 ReexportedDirs android.Paths
202 ReexportedSystemDirs android.Paths
203 ReexportedFlags []string
204 ReexportedGeneratedHeaders android.Paths
205 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400206 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700207
Colin Cross26c34ed2016-09-30 17:10:16 -0700208 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700209 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700210
Dan Willemsena0790e32018-10-12 00:24:23 -0700211 // Path to the dynamic linker binary
212 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700213
214 // For Darwin builds, the path to the second architecture's output that should
215 // be combined with this architectures's output into a FAT MachO file.
216 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400217
218 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
219 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800220
221 // LLNDK headers for the ABI checker to check LLNDK implementation library.
222 LlndkIncludeDirs android.Paths
223 LlndkSystemIncludeDirs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700224}
225
Colin Cross4af21ed2019-11-04 09:37:55 -0800226// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
227// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
228// command line so they can be overridden by the local module flags).
229type LocalOrGlobalFlags struct {
230 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700231 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800232 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700233 CFlags []string // Flags that apply to C and C++ source files
234 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
235 ConlyFlags []string // Flags that apply to C source files
236 CppFlags []string // Flags that apply to C++ source files
237 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700238 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800239}
240
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500241// Flags contains various types of command line flags (and settings) for use in building build
242// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800243type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500244 // Local flags (which individual modules are responsible for). These may override global flags.
245 Local LocalOrGlobalFlags
246 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700247 Global LocalOrGlobalFlags
248 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800249
250 aidlFlags []string // Flags that apply to aidl source files
251 rsFlags []string // Flags that apply to renderscript source files
252 libFlags []string // Flags to add libraries early to the link order
253 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
254 TidyFlags []string // Flags that apply to clang-tidy
255 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700256
Colin Crossc3199482017-03-30 15:03:04 -0700257 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800258 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700259 SystemIncludeFlags []string
260
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800261 Toolchain config.Toolchain
262 Tidy bool // True if ninja .tidy rules should be generated.
263 NeedTidyFiles bool // True if module link should depend on .tidy files
264 GcovCoverage bool // True if coverage files should be generated.
265 SAbiDump bool // True if header abi dumps should be generated.
266 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800267 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800268
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500269 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800270 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500271 // The target-device system path to the dynamic linker.
272 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800273
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700274 CFlagsDeps android.Paths // Files depended on by compiler flags
275 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800276
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500277 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700278 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800279
Colin Cross19878da2019-03-28 14:45:07 -0700280 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700281 protoC bool // Whether to use C instead of C++
282 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700283
284 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200285 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700286}
287
Colin Crossca860ac2016-01-04 14:34:37 -0800288// Properties used to compile all C or C++ modules
289type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700290 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800291 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700292
Yi Kong5786f5c2024-05-28 02:22:34 +0900293 // Aggresively trade performance for smaller binary size.
294 // This should only be used for on-device binaries that are rarely executed and not
295 // performance critical.
296 Optimize_for_size *bool `android:"arch_variant"`
297
Jiyong Parkb35a8192020-08-10 15:59:36 +0900298 // The API level that this module is built against. The APIs of this API level will be
299 // visible at build time, but use of any APIs newer than min_sdk_version will render the
300 // module unloadable on older devices. In the future it will be possible to weakly-link new
301 // APIs, making the behavior match Java: such modules will load on older devices, but
302 // calling new APIs on devices that do not support them will result in a crash.
303 //
304 // This property has the same behavior as sdk_version does for Java modules. For those
305 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
306 // does for Java code.
307 //
308 // In addition, setting this property causes two variants to be built, one for the platform
309 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800310 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700311
Jiyong Parkb35a8192020-08-10 15:59:36 +0900312 // Minimum OS API level supported by this C or C++ module. This property becomes the value
313 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
314 // this property is also used to ensure that the min_sdk_version of the containing module is
315 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
316 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
317 // min_sdk_version of the containing APEX. When the module
318 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900319 Min_sdk_version *string
320
Colin Crossc511bc52020-04-07 16:50:32 +0000321 // If true, always create an sdk variant and don't create a platform variant.
322 Sdk_variant_only *bool
323
Jiyong Parkde866cb2018-12-07 23:08:36 +0900324 AndroidMkSharedLibs []string `blueprint:"mutated"`
325 AndroidMkStaticLibs []string `blueprint:"mutated"`
Ivan Lozano0a468a42024-05-13 21:03:34 -0400326 AndroidMkRlibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900327 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
328 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700329 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900330 HideFromMake bool `blueprint:"mutated"`
331 PreventInstall bool `blueprint:"mutated"`
332 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700333
Yo Chiang219968c2020-09-22 18:45:04 +0800334 // Set by DepsMutator.
335 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
336
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900337 // The name of the image this module is built for
338 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200339
340 // The VNDK version this module is built against. If empty, the module is not
341 // build against the VNDK.
342 VndkVersion string `blueprint:"mutated"`
343
344 // Suffix for the name of Android.mk entries generated by this module
345 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800346
347 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
348 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900349 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900350
Yifan Hong39143a92020-10-26 12:43:12 -0700351 // Make this module available when building for ramdisk.
352 // On device without a dedicated recovery partition, the module is only
353 // available after switching root into
354 // /first_stage_ramdisk. To expose the module before switching root, install
355 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800356 Ramdisk_available *bool
357
Yifan Hong39143a92020-10-26 12:43:12 -0700358 // Make this module available when building for vendor ramdisk.
359 // On device without a dedicated recovery partition, the module is only
360 // available after switching root into
361 // /first_stage_ramdisk. To expose the module before switching root, install
362 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700363 Vendor_ramdisk_available *bool
364
Jiyong Parkf9332f12018-02-01 00:54:12 +0900365 // Make this module available when building for recovery
366 Recovery_available *bool
367
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200368 // Used by imageMutator, set by ImageMutatorBegin()
Jihoon Kang47e91842024-06-19 00:51:16 +0000369 VendorVariantNeeded bool `blueprint:"mutated"`
370 ProductVariantNeeded bool `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200371 CoreVariantNeeded bool `blueprint:"mutated"`
372 RamdiskVariantNeeded bool `blueprint:"mutated"`
373 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
374 RecoveryVariantNeeded bool `blueprint:"mutated"`
375
376 // A list of variations for the "image" mutator of the form
377 //<image name> '.' <version char>, for example, 'vendor.S'
378 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900379
380 // Allows this module to use non-APEX version of libraries. Useful
381 // for building binaries that are started before APEXes are activated.
382 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900383
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000384 // Allows this module to be included in CMake release snapshots to be built outside of Android
385 // build system and source tree.
386 Cmake_snapshot_supported *bool
387
Colin Cross1bc94122021-10-28 13:25:54 -0700388 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000389
390 // Set by factories of module types that can only be referenced from variants compiled against
391 // the SDK.
392 AlwaysSdk bool `blueprint:"mutated"`
393
394 // Variant is an SDK variant created by sdkMutator
395 IsSdkVariant bool `blueprint:"mutated"`
396 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
397 // variant to have a ".sdk" suffix.
398 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700399
Jiyong Park46a512f2020-12-04 18:02:13 +0900400 // List of APEXes that this module has private access to for testing purpose. The module
401 // can depend on libraries that are not exported by the APEXes and use private symbols
402 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000403 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800404
405 Target struct {
406 Platform struct {
407 // List of modules required by the core variant.
408 Required []string `android:"arch_variant"`
409
410 // List of modules not required by the core variant.
411 Exclude_required []string `android:"arch_variant"`
412 } `android:"arch_variant"`
413
414 Recovery struct {
415 // List of modules required by the recovery variant.
416 Required []string `android:"arch_variant"`
417
418 // List of modules not required by the recovery variant.
419 Exclude_required []string `android:"arch_variant"`
420 } `android:"arch_variant"`
421 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700422}
423
424type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900425 // whether this module should be allowed to be directly depended by other
426 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900427 // If set to true, two variants will be built separately, one like
428 // normal, and the other limited to the set of libraries and headers
429 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700430 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900431 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700432 // so it shouldn't have any unversioned runtime dependencies, or
433 // make assumptions about the system that may not be true in the
434 // future.
435 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900436 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900437 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900438 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900439 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900440 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700441 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
442 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900443
Justin Yunebcf0c52021-01-08 18:00:19 +0900444 // This is the same as the "vendor_available" except that the install path
445 // of the vendor variant is /odm or /vendor/odm.
446 // By replacing "vendor_available: true" with "odm_available: true", the
447 // module will install its vendor variant to the /odm partition or /vendor/odm.
448 // As the modules with "odm_available: true" still create the vendor variants,
449 // they can link to the other vendor modules as the vendor_available modules do.
450 // Also, the vendor modules can link to odm_available modules.
451 //
452 // It may not be used for VNDK modules.
453 Odm_available *bool
454
Justin Yun63e9ec72020-10-29 16:49:43 +0900455 // whether this module should be allowed to be directly depended by other
456 // modules with `product_specific: true` or `product_available: true`.
457 // If set to true, an additional product variant will be built separately
458 // that is limited to the set of libraries and headers that are exposed to
459 // /product modules.
460 //
461 // The product variant may be used with a different (newer) /system,
462 // so it shouldn't have any unversioned runtime dependencies, or
463 // make assumptions about the system that may not be true in the
464 // future.
465 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900466 // If set to false, this module becomes inaccessible from /product modules.
467 //
468 // Different from the 'vendor_available' property, the modules with
469 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
470 // library without 'product_available' may not be depended on by any other
471 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900472 //
473 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
474 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
475 Product_available *bool
476
Jiyong Park5fb8c102018-04-09 12:03:06 +0900477 // whether this module is capable of being loaded with other instance
478 // (possibly an older version) of the same module in the same process.
479 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
480 // can be double loaded in a vendor process if the library is also a
481 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
482 // explicitly marked as `double_loadable: true` by the owner, or the dependency
483 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
484 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800485
486 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
487 IsLLNDK bool `blueprint:"mutated"`
488
Colin Cross5271fea2021-04-27 13:06:04 -0700489 // IsVendorPublicLibrary is set for the core and product variants of a library that has
490 // vendor_public_library stubs.
491 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800492}
493
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500494// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
495// to understanding details about the type of the current module.
496// For example, one might call these functions to determine whether the current module is a static
497// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800498type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800499 static() bool
500 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700501 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800502 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900503 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900504 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900505 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700506 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900507 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700508 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800509 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900510 minSdkVersion() string
511 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700512 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700513 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800514 IsLlndk() bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800515 isImplementationForLLNDKPublic() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700516 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900517 inProduct() bool
518 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800519 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700520 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900521 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900522 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700523 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700524 baseModuleName() string
Colin Cross3513fb12024-01-24 14:44:47 -0800525 isAfdoCompile(ctx ModuleContext) bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000526 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800527 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900528 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800529 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800530 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800531 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700532 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700533 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900534 bootstrap() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700535 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700536 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800537 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800538 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800539 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800540 notInPlatform() bool
Yi Kong5786f5c2024-05-28 02:22:34 +0900541 optimizeForSize() bool
Yu Liu76d94462024-10-31 23:32:36 +0000542 getOrCreateMakeVarsInfo() *CcMakeVarsInfo
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800543}
544
545type SharedFlags struct {
546 numSharedFlags int
547 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800548}
549
550type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700551 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800552 ModuleContextIntf
553}
554
555type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700556 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800557 ModuleContextIntf
558}
559
Colin Cross37047f12016-12-13 17:06:13 -0800560type DepsContext interface {
561 android.BottomUpMutatorContext
562 ModuleContextIntf
563}
564
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500565// feature represents additional (optional) steps to building cc-related modules, such as invocation
566// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800567type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800568 flags(ctx ModuleContext, flags Flags) Flags
569 props() []interface{}
570}
571
Joe Onorato37f900c2023-07-18 16:58:16 -0700572// Information returned from Generator about the source code it's generating
573type GeneratedSource struct {
574 IncludeDirs android.Paths
575 Sources android.Paths
576 Headers android.Paths
577 ReexportedDirs android.Paths
578}
579
580// generator allows injection of generated code
581type Generator interface {
582 GeneratorProps() []interface{}
583 GeneratorInit(ctx BaseModuleContext)
584 GeneratorDeps(ctx DepsContext, deps Deps) Deps
585 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
586 GeneratorSources(ctx ModuleContext) GeneratedSource
587 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
588}
589
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500590// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500591// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800592type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700593 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800594 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800595 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700596 compilerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000597 baseCompilerProps() BaseCompilerProperties
Colin Cross42742b82016-08-01 13:20:05 -0700598
Colin Cross76fada02016-07-27 10:31:13 -0700599 appendCflags([]string)
600 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700601 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800602}
603
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500604// linker is the interface for a linker decorator object. Individual module types can provide
605// their own implementation for this decorator, and thus specify custom logic regarding build
606// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800607type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700608 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800609 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700610 linkerFlags(ctx ModuleContext, flags Flags) Flags
611 linkerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000612 baseLinkerProps() BaseLinkerProperties
Ivan Lozanobd721262018-11-27 14:33:03 -0800613 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700614
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700615 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700616 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900617 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800618 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700619
620 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900621 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000622
623 // Get the deps that have been explicitly specified in the properties.
Cole Fauste8a87832024-09-11 11:35:46 -0700624 linkerSpecifiedDeps(ctx android.ConfigurableEvaluatorContext, module *Module, specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800625
626 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000627}
628
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500629// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000630type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500631 sharedLibs []string
632 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
633 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700634 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800635}
636
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500637// installer is the interface for an installer helper object. This helper is responsible for
638// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800639type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700640 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700641 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000642 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800643 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700644 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700645 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900646 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000647 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900648 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800649}
650
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800651type xref interface {
652 XrefCcFiles() android.Paths
653}
654
Inseob Kima1888ce2022-10-04 14:42:02 +0900655type overridable interface {
656 overriddenModules() []string
657}
658
Colin Cross6e511a92020-07-27 21:26:48 -0700659type libraryDependencyKind int
660
661const (
662 headerLibraryDependency = iota
663 sharedLibraryDependency
664 staticLibraryDependency
Ivan Lozano0a468a42024-05-13 21:03:34 -0400665 rlibLibraryDependency
Colin Cross6e511a92020-07-27 21:26:48 -0700666)
667
668func (k libraryDependencyKind) String() string {
669 switch k {
670 case headerLibraryDependency:
671 return "headerLibraryDependency"
672 case sharedLibraryDependency:
673 return "sharedLibraryDependency"
674 case staticLibraryDependency:
675 return "staticLibraryDependency"
Ivan Lozano0a468a42024-05-13 21:03:34 -0400676 case rlibLibraryDependency:
677 return "rlibLibraryDependency"
Colin Cross6e511a92020-07-27 21:26:48 -0700678 default:
679 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
680 }
681}
682
683type libraryDependencyOrder int
684
685const (
686 earlyLibraryDependency = -1
687 normalLibraryDependency = 0
688 lateLibraryDependency = 1
689)
690
691func (o libraryDependencyOrder) String() string {
692 switch o {
693 case earlyLibraryDependency:
694 return "earlyLibraryDependency"
695 case normalLibraryDependency:
696 return "normalLibraryDependency"
697 case lateLibraryDependency:
698 return "lateLibraryDependency"
699 default:
700 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
701 }
702}
703
704// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
705// tags that have a set of predefined tag objects that are reused for each dependency, a
706// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
707// That means that comparing a libraryDependencyTag for equality will only be equal if all
708// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
709// then check individual metadata fields instead.
710type libraryDependencyTag struct {
711 blueprint.BaseDependencyTag
712
713 // These are exported so that fmt.Printf("%#v") can call their String methods.
714 Kind libraryDependencyKind
715 Order libraryDependencyOrder
716
717 wholeStatic bool
718
719 reexportFlags bool
720 explicitlyVersioned bool
721 dataLib bool
722 ndk bool
723
724 staticUnwinder bool
725
726 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900727
Cindy Zhou18417cb2020-12-10 07:12:38 -0800728 // Whether or not this dependency should skip the apex dependency check
729 skipApexAllowedDependenciesCheck bool
730
Jiyong Parke3867542020-12-03 17:28:25 +0900731 // Whether or not this dependency has to be followed for the apex variants
732 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900733 // Whether or not this dependency has to be followed for the non-apex variants
734 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000735
736 // If true, don't automatically export symbols from the static library into a shared library.
737 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700738}
739
740// header returns true if the libraryDependencyTag is tagging a header lib dependency.
741func (d libraryDependencyTag) header() bool {
742 return d.Kind == headerLibraryDependency
743}
744
745// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
746func (d libraryDependencyTag) shared() bool {
747 return d.Kind == sharedLibraryDependency
748}
749
750// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
751func (d libraryDependencyTag) static() bool {
752 return d.Kind == staticLibraryDependency
753}
754
Colin Cross65cb3142021-12-10 23:05:02 +0000755func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
756 if d.shared() {
757 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
758 }
759 return nil
760}
761
762var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
763
Colin Crosse9fe2942020-11-10 18:12:15 -0800764// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
765// binaries or other shared libraries are installed as dependencies.
766func (d libraryDependencyTag) InstallDepNeeded() bool {
767 return d.shared()
768}
769
770var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
771
Yu Liu67a28422024-03-05 00:36:31 +0000772func (d libraryDependencyTag) PropagateAconfigValidation() bool {
773 return d.static()
774}
775
776var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
777
Colin Crosse9fe2942020-11-10 18:12:15 -0800778// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700779// libraryDependencyTag. Each tag object is created globally and reused for multiple
780// dependencies (although since the object contains no references, assigning a tag to a
781// variable and modifying it will not modify the original). Users can compare the tag
782// returned by ctx.OtherModuleDependencyTag against the global original
783type dependencyTag struct {
784 blueprint.BaseDependencyTag
785 name string
786}
787
Colin Crosse9fe2942020-11-10 18:12:15 -0800788// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
789// libraryDependencyTag, but where the dependency needs to be installed when the parent is
790// installed.
791type installDependencyTag struct {
792 blueprint.BaseDependencyTag
793 android.InstallAlwaysNeededDependencyTag
794 name string
795}
796
Colin Crossc99deeb2016-04-11 15:06:20 -0700797var (
Colin Cross6e511a92020-07-27 21:26:48 -0700798 genSourceDepTag = dependencyTag{name: "gen source"}
799 genHeaderDepTag = dependencyTag{name: "gen header"}
800 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
801 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900802 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700803 reuseObjTag = dependencyTag{name: "reuse objects"}
804 staticVariantTag = dependencyTag{name: "static variant"}
805 vndkExtDepTag = dependencyTag{name: "vndk extends"}
806 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700807 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800808 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700809 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000810 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500811 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400812 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800813 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700814)
815
Roland Levillainf89cd092019-07-29 16:22:59 +0100816func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700817 ccLibDepTag, ok := depTag.(libraryDependencyTag)
818 return ok && ccLibDepTag.shared()
819}
820
821func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
822 ccLibDepTag, ok := depTag.(libraryDependencyTag)
823 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100824}
825
Zach Johnson3df4e632020-11-06 11:56:27 -0800826func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
827 ccLibDepTag, ok := depTag.(libraryDependencyTag)
828 return ok && ccLibDepTag.header()
829}
830
Roland Levillainf89cd092019-07-29 16:22:59 +0100831func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800832 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100833}
834
Colin Crossca860ac2016-01-04 14:34:37 -0800835// Module contains the properties and members used by all C/C++ module types, and implements
836// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500837// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
838// interface.
839//
840// To define a C/C++ related module, construct a new Module object and point its delegates to
841// type-specific structs. These delegates will be invoked to register module-specific build
842// statements which may be unique to the module type. For example, module.compiler.compile() should
843// be defined so as to register build statements which are responsible for compiling the module.
844//
845// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
846// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
847// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
848// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800849type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700850 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700851
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700852 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700853 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700854 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700855
Colin Crossca860ac2016-01-04 14:34:37 -0800856 // initialize before calling Init
Yu Liu76d94462024-10-31 23:32:36 +0000857 hod android.HostOrDeviceSupported
858 multilib android.Multilib
859 testModule bool
860 incremental bool
Colin Crossc472d572015-03-17 15:06:21 -0700861
Paul Duffina0843f62019-12-13 19:50:38 +0000862 // Allowable SdkMemberTypes of this module type.
863 sdkMemberTypes []android.SdkMemberType
864
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500865 // decorator delegates, initialize before calling Init
866 // these may contain module-specific implementations, and effectively allow for custom
867 // type-specific logic. These members may reference different objects or the same object.
868 // Functions of these decorators will be invoked to initialize and register type-specific
869 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800870 generators []Generator
871 compiler compiler
872 linker linker
873 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500874
Spandan Dase12d2522023-09-12 21:42:31 +0000875 features []feature
876 stl *stl
877 sanitize *sanitize
878 coverage *coverage
879 fuzzer *fuzzer
880 sabi *sabi
Spandan Dase12d2522023-09-12 21:42:31 +0000881 lto *lto
882 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000883 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800884
Colin Cross31076b32020-10-23 17:22:06 -0700885 library libraryInterface
886
Colin Cross635c3b02016-05-18 15:37:25 -0700887 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800888
Colin Crossb98c8b02016-07-29 13:44:28 -0700889 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700890
Yu Liue70976d2024-10-15 20:45:35 +0000891 subAndroidMkOnce map[subAndroidMkProviderInfoProducer]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800892
893 // Flags used to compile this module
894 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700895
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800896 // Shared flags among build rules of this module
897 sharedFlags SharedFlags
898
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800899 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700900 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900901
902 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800903 // Kythe (source file indexer) paths for this compilation module
904 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700905 // Object .o file output paths for this compilation module
906 objFiles android.Paths
907 // Tidy .tidy file output paths for this compilation module
908 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900909
910 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700911 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700912
913 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800914
Inseob Kim37e0bb02024-04-29 15:54:44 +0900915 logtagsPaths android.Paths
Ivan Lozanofd47b1a2024-05-17 14:13:41 -0400916
917 WholeRustStaticlib bool
Cole Faust96a692b2024-08-08 14:47:51 -0700918
919 hasAidl bool
920 hasLex bool
921 hasProto bool
922 hasRenderscript bool
923 hasSysprop bool
924 hasWinMsg bool
925 hasYacc bool
Yu Liu76d94462024-10-31 23:32:36 +0000926
927 makeVarsInfo *CcMakeVarsInfo
Colin Crossc472d572015-03-17 15:06:21 -0700928}
929
Yu Liu76d94462024-10-31 23:32:36 +0000930func (c *Module) IncrementalSupported() bool {
931 return c.incremental
932}
933
934var _ blueprint.Incremental = (*Module)(nil)
935
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200936func (c *Module) AddJSONData(d *map[string]interface{}) {
937 c.AndroidModuleBase().AddJSONData(d)
938 (*d)["Cc"] = map[string]interface{}{
939 "SdkVersion": c.SdkVersion(),
940 "MinSdkVersion": c.MinSdkVersion(),
941 "VndkVersion": c.VndkVersion(),
942 "ProductSpecific": c.ProductSpecific(),
943 "SocSpecific": c.SocSpecific(),
944 "DeviceSpecific": c.DeviceSpecific(),
945 "InProduct": c.InProduct(),
946 "InVendor": c.InVendor(),
947 "InRamdisk": c.InRamdisk(),
948 "InVendorRamdisk": c.InVendorRamdisk(),
949 "InRecovery": c.InRecovery(),
950 "VendorAvailable": c.VendorAvailable(),
951 "ProductAvailable": c.ProductAvailable(),
952 "RamdiskAvailable": c.RamdiskAvailable(),
953 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
954 "RecoveryAvailable": c.RecoveryAvailable(),
955 "OdmAvailable": c.OdmAvailable(),
956 "InstallInData": c.InstallInData(),
957 "InstallInRamdisk": c.InstallInRamdisk(),
958 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
959 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
960 "InstallInRecovery": c.InstallInRecovery(),
961 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200962 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200963 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
964 "ApexSdkVersion": c.apexSdkVersion,
965 "TestFor": c.TestFor(),
Cole Faust96a692b2024-08-08 14:47:51 -0700966 "AidlSrcs": c.hasAidl,
967 "LexSrcs": c.hasLex,
968 "ProtoSrcs": c.hasProto,
969 "RenderscriptSrcs": c.hasRenderscript,
970 "SyspropSrcs": c.hasSysprop,
971 "WinMsgSrcs": c.hasWinMsg,
972 "YaccSrsc": c.hasYacc,
973 "OnlyCSrcs": !(c.hasAidl || c.hasLex || c.hasProto || c.hasRenderscript || c.hasSysprop || c.hasWinMsg || c.hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900974 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200975 }
976}
977
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500978func (c *Module) SetPreventInstall() {
979 c.Properties.PreventInstall = true
980}
981
982func (c *Module) SetHideFromMake() {
983 c.Properties.HideFromMake = true
984}
985
Ivan Lozanod7586b62021-04-01 09:49:36 -0400986func (c *Module) HiddenFromMake() bool {
987 return c.Properties.HideFromMake
988}
989
Cole Fauste8a87832024-09-11 11:35:46 -0700990func (c *Module) RequiredModuleNames(ctx android.ConfigurableEvaluatorContext) []string {
Cole Faust43ddd082024-06-17 12:32:40 -0700991 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800992 if c.ImageVariation().Variation == android.CoreVariation {
993 required = append(required, c.Properties.Target.Platform.Required...)
994 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
995 } else if c.InRecovery() {
996 required = append(required, c.Properties.Target.Recovery.Required...)
997 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
998 }
999 return android.FirstUniqueStrings(required)
1000}
1001
Ivan Lozano52767be2019-10-18 14:49:46 -07001002func (c *Module) Toc() android.OptionalPath {
1003 if c.linker != nil {
1004 if library, ok := c.linker.(libraryInterface); ok {
1005 return library.toc()
1006 }
1007 }
1008 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
1009}
1010
1011func (c *Module) ApiLevel() string {
1012 if c.linker != nil {
1013 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001014 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001015 }
1016 }
1017 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1018}
1019
1020func (c *Module) Static() bool {
1021 if c.linker != nil {
1022 if library, ok := c.linker.(libraryInterface); ok {
1023 return library.static()
1024 }
1025 }
1026 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1027}
1028
1029func (c *Module) Shared() bool {
1030 if c.linker != nil {
1031 if library, ok := c.linker.(libraryInterface); ok {
1032 return library.shared()
1033 }
1034 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001035
Ivan Lozano52767be2019-10-18 14:49:46 -07001036 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1037}
1038
1039func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001040 if c.stl != nil {
1041 return c.stl.Properties.SelectedStl
1042 }
1043 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001044}
1045
Ivan Lozano52767be2019-10-18 14:49:46 -07001046func (c *Module) StubDecorator() bool {
1047 if _, ok := c.linker.(*stubDecorator); ok {
1048 return true
1049 }
1050 return false
1051}
1052
Yi Kong5786f5c2024-05-28 02:22:34 +09001053func (c *Module) OptimizeForSize() bool {
1054 return Bool(c.Properties.Optimize_for_size)
1055}
1056
Ivan Lozano52767be2019-10-18 14:49:46 -07001057func (c *Module) SdkVersion() string {
1058 return String(c.Properties.Sdk_version)
1059}
1060
Artur Satayev480e25b2020-04-27 18:53:18 +01001061func (c *Module) MinSdkVersion() string {
1062 return String(c.Properties.Min_sdk_version)
1063}
1064
Jiyong Park5df7bd32021-08-25 16:18:46 +09001065func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001066 if linker, ok := c.linker.(*objectLinker); ok {
1067 return linker.isCrt()
1068 }
1069 return false
1070}
1071
Jiyong Park5df7bd32021-08-25 16:18:46 +09001072func (c *Module) SplitPerApiLevel() bool {
1073 return c.canUseSdk() && c.isCrt()
1074}
1075
Colin Crossc511bc52020-04-07 16:50:32 +00001076func (c *Module) AlwaysSdk() bool {
1077 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1078}
1079
Ivan Lozano183a3212019-10-18 14:18:45 -07001080func (c *Module) CcLibrary() bool {
1081 if c.linker != nil {
1082 if _, ok := c.linker.(*libraryDecorator); ok {
1083 return true
1084 }
Colin Crossd48fe732020-09-23 20:37:24 -07001085 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1086 return true
1087 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001088 }
1089 return false
1090}
1091
1092func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001093 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001094 return true
1095 }
1096 return false
1097}
1098
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001099func (c *Module) RlibStd() bool {
1100 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1101}
1102
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001103func (c *Module) RustLibraryInterface() bool {
1104 return false
1105}
1106
Ivan Lozano0a468a42024-05-13 21:03:34 -04001107func (c *Module) CrateName() string {
1108 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1109}
1110
1111func (c *Module) ExportedCrateLinkDirs() []string {
1112 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1113}
1114
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001115func (c *Module) IsFuzzModule() bool {
1116 if _, ok := c.compiler.(*fuzzBinary); ok {
1117 return true
1118 }
1119 return false
1120}
1121
1122func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1123 return c.FuzzModule
1124}
1125
1126func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1127 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1128 return fuzzer.fuzzPackagedModule
1129 }
1130 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1131}
1132
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001133func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001134 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1135 return fuzzer.sharedLibraries
1136 }
1137 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1138}
1139
Ivan Lozano2b262972019-11-21 12:30:50 -08001140func (c *Module) NonCcVariants() bool {
1141 return false
1142}
1143
Ivan Lozano183a3212019-10-18 14:18:45 -07001144func (c *Module) SetStatic() {
1145 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001146 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001147 library.setStatic()
1148 return
1149 }
1150 }
1151 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1152}
1153
1154func (c *Module) SetShared() {
1155 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001156 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001157 library.setShared()
1158 return
1159 }
1160 }
1161 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1162}
1163
1164func (c *Module) BuildStaticVariant() bool {
1165 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001166 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001167 return library.buildStatic()
1168 }
1169 }
1170 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1171}
1172
1173func (c *Module) BuildSharedVariant() bool {
1174 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001175 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001176 return library.buildShared()
1177 }
1178 }
1179 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1180}
1181
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04001182func (c *Module) BuildRlibVariant() bool {
1183 // cc modules can never build rlib variants
1184 return false
1185}
1186
1187func (c *Module) IsRustFFI() bool {
1188 // cc modules are not Rust modules
1189 return false
1190}
1191
Ivan Lozano183a3212019-10-18 14:18:45 -07001192func (c *Module) Module() android.Module {
1193 return c
1194}
1195
Jiyong Parkc20eee32018-09-05 22:36:17 +09001196func (c *Module) OutputFile() android.OptionalPath {
1197 return c.outputFile
1198}
1199
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001200func (c *Module) CoverageFiles() android.Paths {
1201 if c.linker != nil {
1202 if library, ok := c.linker.(libraryInterface); ok {
1203 return library.objs().coverageFiles
1204 }
1205 }
1206 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1207}
1208
Ivan Lozano183a3212019-10-18 14:18:45 -07001209var _ LinkableInterface = (*Module)(nil)
1210
Jiyong Park719b4462019-01-13 00:39:51 +09001211func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001212 if c.linker != nil {
1213 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001214 }
1215 return nil
1216}
1217
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001218func (c *Module) CoverageOutputFile() android.OptionalPath {
1219 if c.linker != nil {
1220 return c.linker.coverageOutputFilePath()
1221 }
1222 return android.OptionalPath{}
1223}
1224
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001225func (c *Module) RelativeInstallPath() string {
1226 if c.installer != nil {
1227 return c.installer.relativeInstallPath()
1228 }
1229 return ""
1230}
1231
Jooyung Han344d5432019-08-23 11:17:39 +09001232func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001233 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001234}
1235
Colin Cross36242852017-06-23 15:06:31 -07001236func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001237 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001238 for _, generator := range c.generators {
1239 c.AddProperties(generator.GeneratorProps()...)
1240 }
Colin Crossca860ac2016-01-04 14:34:37 -08001241 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001242 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001243 }
1244 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001245 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001246 }
1247 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001248 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001249 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001250 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001251 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001252 }
Colin Cross16b23492016-01-06 14:41:07 -08001253 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001254 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001255 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001256 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001257 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001258 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001259 if c.fuzzer != nil {
1260 c.AddProperties(c.fuzzer.props()...)
1261 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001262 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001263 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001264 }
Stephen Craneba090d12017-05-09 15:44:35 -07001265 if c.lto != nil {
1266 c.AddProperties(c.lto.props()...)
1267 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001268 if c.afdo != nil {
1269 c.AddProperties(c.afdo.props()...)
1270 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001271 if c.orderfile != nil {
1272 c.AddProperties(c.orderfile.props()...)
1273 }
Colin Crossca860ac2016-01-04 14:34:37 -08001274 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001275 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001276 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001277 // Allow test-only on libraries that are not cc_test_library
1278 if c.library != nil && !c.testLibrary() {
1279 c.AddProperties(&c.sourceProperties)
1280 }
Colin Crossc472d572015-03-17 15:06:21 -07001281
Colin Cross36242852017-06-23 15:06:31 -07001282 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001283 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001284 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001285
Colin Cross36242852017-06-23 15:06:31 -07001286 return c
Colin Crossc472d572015-03-17 15:06:21 -07001287}
1288
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001289// UseVndk() returns true if this module is built against VNDK.
1290// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001291func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001292 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001293}
1294
Colin Crossc511bc52020-04-07 16:50:32 +00001295func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001296 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001297 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001298}
1299
1300func (c *Module) UseSdk() bool {
1301 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001302 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001303 }
1304 return false
1305}
1306
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001307func (c *Module) isCoverageVariant() bool {
1308 return c.coverage.Properties.IsCoverageVariant
1309}
1310
Colin Cross95f1ca02020-10-29 20:47:22 -07001311func (c *Module) IsNdk(config android.Config) bool {
1312 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001313}
1314
Colin Cross127bb8b2020-12-16 16:46:01 -08001315func (c *Module) IsLlndk() bool {
1316 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001317}
1318
Colin Cross1f3f1302021-04-26 18:37:44 -07001319func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001320 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001321 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001322}
1323
Colin Cross5271fea2021-04-27 13:06:04 -07001324func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1325 lib := moduleLibraryInterface(m)
1326 return lib != nil && (lib.hasVendorPublicLibrary())
1327}
1328
1329// IsVendorPublicLibrary returns true for vendor public libraries.
1330func (c *Module) IsVendorPublicLibrary() bool {
1331 return c.VendorProperties.IsVendorPublicLibrary
1332}
1333
Ivan Lozanof1868af2022-04-12 13:08:36 -04001334func (c *Module) IsVndkPrebuiltLibrary() bool {
1335 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1336 return true
1337 }
1338 return false
1339}
1340
1341func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1342 return c.Properties.SdkAndPlatformVariantVisibleToMake
1343}
1344
Ivan Lozanod7586b62021-04-01 09:49:36 -04001345func (c *Module) HasLlndkStubs() bool {
1346 lib := moduleLibraryInterface(c)
1347 return lib != nil && lib.hasLLNDKStubs()
1348}
1349
1350func (c *Module) StubsVersion() string {
1351 if lib, ok := c.linker.(versionedInterface); ok {
1352 return lib.stubsVersion()
1353 }
1354 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1355}
1356
Colin Cross127bb8b2020-12-16 16:46:01 -08001357// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1358// and does not set llndk.vendor_available: false.
1359func (c *Module) isImplementationForLLNDKPublic() bool {
1360 library, _ := c.library.(*libraryDecorator)
1361 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001362 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001363}
1364
Colin Cross3513fb12024-01-24 14:44:47 -08001365func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001366 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001367 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001368 }
1369 return false
1370}
1371
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001372func (c *Module) isOrderfileCompile() bool {
1373 if orderfile := c.orderfile; orderfile != nil {
1374 return orderfile.Properties.OrderfileLoad
1375 }
1376 return false
1377}
1378
Yi Kongc702ebd2022-08-19 16:02:45 +08001379func (c *Module) isCfi() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001380 return c.sanitize.isSanitizerEnabled(cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001381}
1382
Yi Konged79fa32023-06-04 17:15:42 +09001383func (c *Module) isFuzzer() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001384 return c.sanitize.isSanitizerEnabled(Fuzzer)
Yi Konged79fa32023-06-04 17:15:42 +09001385}
1386
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001387func (c *Module) isNDKStubLibrary() bool {
1388 if _, ok := c.compiler.(*stubDecorator); ok {
1389 return true
1390 }
1391 return false
1392}
1393
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001394func (c *Module) SubName() string {
1395 return c.Properties.SubName
1396}
1397
Jiyong Park25fc6a92018-11-18 18:02:45 +09001398func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001399 if lib := c.library; lib != nil {
1400 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001401 }
1402 return false
1403}
1404
1405func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001406 if lib := c.library; lib != nil {
1407 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001408 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001409 return false
1410}
1411
Alan Stokes73feba32022-11-14 12:21:24 +00001412func (c *Module) IsStubsImplementationRequired() bool {
1413 if lib := c.library; lib != nil {
1414 return lib.isStubsImplementationRequired()
1415 }
1416 return false
1417}
1418
Colin Cross0477b422020-10-13 18:43:54 -07001419// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1420// the implementation. If it is an implementation library it returns its own name.
1421func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1422 name := ctx.OtherModuleName(c)
1423 if versioned, ok := c.linker.(versionedInterface); ok {
1424 name = versioned.implementationModuleName(name)
1425 }
1426 return name
1427}
1428
Martin Stjernholm2856c662020-12-02 15:03:42 +00001429// Similar to ImplementationModuleName, but uses the Make variant of the module
1430// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1431// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1432// under the premise that the prebuilt module overrides its source counterpart
1433// if it is exposed to Make).
1434func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1435 name := c.BaseModuleName()
1436 if versioned, ok := c.linker.(versionedInterface); ok {
1437 name = versioned.implementationModuleName(name)
1438 }
1439 return name
1440}
1441
Jiyong Park7d55b612021-06-11 17:22:09 +09001442func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001443 return Bool(c.Properties.Bootstrap)
1444}
1445
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001446func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001447 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1448 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1449 return false
1450 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001451 return c.linker != nil && c.linker.nativeCoverage()
1452}
1453
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001454func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001455 if p, ok := c.linker.(SnapshotInterface); ok {
1456 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001457 }
1458 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001459}
1460
Jiyong Parkf1194352019-02-25 11:05:47 +09001461func isBionic(name string) bool {
1462 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001463 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001464 return true
1465 }
1466 return false
1467}
1468
Martin Stjernholm279de572019-09-10 23:18:20 +01001469func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001470 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001471 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001472 }
1473 return isBionic(name)
1474}
1475
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001476func (c *Module) XrefCcFiles() android.Paths {
1477 return c.kytheFiles
1478}
1479
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001480func (c *Module) isCfiAssemblySupportEnabled() bool {
1481 return c.sanitize != nil &&
1482 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1483}
1484
Inseob Kim800d1142021-06-14 12:03:51 +09001485func (c *Module) InstallInRoot() bool {
1486 return c.installer != nil && c.installer.installInRoot()
1487}
1488
Colin Crossca860ac2016-01-04 14:34:37 -08001489type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001490 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001491 moduleContextImpl
1492}
1493
Colin Cross37047f12016-12-13 17:06:13 -08001494type depsContext struct {
1495 android.BottomUpMutatorContext
1496 moduleContextImpl
1497}
1498
Colin Crossca860ac2016-01-04 14:34:37 -08001499type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001500 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001501 moduleContextImpl
1502}
1503
1504type moduleContextImpl struct {
1505 mod *Module
1506 ctx BaseModuleContext
1507}
1508
Colin Crossb98c8b02016-07-29 13:44:28 -07001509func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001510 return ctx.mod.toolchain(ctx.ctx)
1511}
1512
1513func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001514 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001515}
1516
1517func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001518 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001519}
1520
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001521func (ctx *moduleContextImpl) testBinary() bool {
1522 return ctx.mod.testBinary()
1523}
1524
Yi Kong56fc1b62022-09-06 16:24:00 +08001525func (ctx *moduleContextImpl) testLibrary() bool {
1526 return ctx.mod.testLibrary()
1527}
1528
Jiyong Park1d1119f2019-07-29 21:27:18 +09001529func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001530 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001531}
1532
Inseob Kim7f283f42020-06-01 21:53:49 +09001533func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001534 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001535}
1536
Inseob Kim1042d292020-06-01 23:23:05 +09001537func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001538 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001539}
1540
Yi Kong5786f5c2024-05-28 02:22:34 +09001541func (ctx *moduleContextImpl) optimizeForSize() bool {
1542 return ctx.mod.OptimizeForSize()
1543}
1544
Jooyung Hanccce2f22020-03-07 03:45:53 +09001545func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001546 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001547}
1548
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001549func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001550 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001551}
1552
1553func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001554 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001555 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001556 }
1557 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001558}
1559
Jiyong Parkb35a8192020-08-10 15:59:36 +09001560func (ctx *moduleContextImpl) minSdkVersion() string {
1561 ver := ctx.mod.MinSdkVersion()
1562 if ver == "apex_inherit" && !ctx.isForPlatform() {
1563 ver = ctx.apexSdkVersion().String()
1564 }
1565 if ver == "apex_inherit" || ver == "" {
1566 ver = ctx.sdkVersion()
1567 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001568
1569 if ctx.ctx.Device() {
1570 config := ctx.ctx.Config()
Kiyoung Kim8f05c542024-05-22 16:50:34 +09001571 if ctx.inVendor() {
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001572 // If building for vendor with final API, then use the latest _stable_ API as "current".
1573 if config.VendorApiLevelFrozen() && (ver == "" || ver == "current") {
1574 ver = config.PlatformSdkVersion().String()
1575 }
1576 }
1577 }
1578
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001579 // For crt objects, the meaning of min_sdk_version is very different from other types of
1580 // module. For them, min_sdk_version defines the oldest version that the build system will
1581 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1582 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1583 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001584 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1585 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1586 // support such an old version. The version is set to the later version in case when the
1587 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1588 // it's for an APEX.
1589 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1590 if ctx.isForPlatform() {
1591 ver = strconv.Itoa(android.FutureApiLevelInt)
1592 } else { // for apex
1593 ver = ctx.apexSdkVersion().String()
1594 if ver == "" { // in case when min_sdk_version was not set by the APEX
1595 ver = ctx.sdkVersion()
1596 }
1597 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001598 }
1599
Jiyong Parkb35a8192020-08-10 15:59:36 +09001600 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1601 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1602 minSdkVersionInt, err2 := strconv.Atoi(ver)
1603 if err == nil && err2 == nil {
1604 if sdkVersionInt < minSdkVersionInt {
1605 return strconv.Itoa(sdkVersionInt)
1606 }
1607 }
1608 return ver
1609}
1610
1611func (ctx *moduleContextImpl) isSdkVariant() bool {
1612 return ctx.mod.IsSdkVariant()
1613}
1614
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001615func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001616 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001617}
Justin Yun8effde42017-06-23 19:24:43 +09001618
Kiyoung Kimaa394802024-01-08 12:55:45 +09001619func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1620 return ctx.mod.InVendorOrProduct()
1621}
1622
Colin Cross95f1ca02020-10-29 20:47:22 -07001623func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1624 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001625}
1626
Colin Cross127bb8b2020-12-16 16:46:01 -08001627func (ctx *moduleContextImpl) IsLlndk() bool {
1628 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001629}
1630
Colin Cross127bb8b2020-12-16 16:46:01 -08001631func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1632 return ctx.mod.isImplementationForLLNDKPublic()
1633}
1634
Colin Cross3513fb12024-01-24 14:44:47 -08001635func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1636 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001637}
1638
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001639func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1640 return ctx.mod.isOrderfileCompile()
1641}
1642
Yi Kongc702ebd2022-08-19 16:02:45 +08001643func (ctx *moduleContextImpl) isCfi() bool {
1644 return ctx.mod.isCfi()
1645}
1646
Yi Konged79fa32023-06-04 17:15:42 +09001647func (ctx *moduleContextImpl) isFuzzer() bool {
1648 return ctx.mod.isFuzzer()
1649}
1650
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001651func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1652 return ctx.mod.isNDKStubLibrary()
1653}
1654
Colin Cross5271fea2021-04-27 13:06:04 -07001655func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1656 return ctx.mod.IsVendorPublicLibrary()
1657}
1658
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001659func (ctx *moduleContextImpl) selectedStl() string {
1660 if stl := ctx.mod.stl; stl != nil {
1661 return stl.Properties.SelectedStl
1662 }
1663 return ""
1664}
1665
Ivan Lozanobd721262018-11-27 14:33:03 -08001666func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1667 return ctx.mod.linker.useClangLld(actx)
1668}
1669
Colin Crossce75d2c2016-10-06 16:12:58 -07001670func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001671 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001672}
1673
Logan Chiene274fc92019-12-03 11:18:32 -08001674func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001675 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1676 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001677}
1678
Colin Crosse07f2312020-08-13 11:24:56 -07001679func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001680 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1681 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001682}
1683
Dan Albertc8060532020-07-22 22:32:17 -07001684func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001685 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001686}
1687
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001688func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001689 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001690}
1691
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001692func (ctx *moduleContextImpl) nativeCoverage() bool {
1693 return ctx.mod.nativeCoverage()
1694}
1695
Colin Cross56a83212020-09-15 18:30:11 -07001696func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1697 return ctx.mod.DirectlyInAnyApex()
1698}
1699
Colin Cross95b07f22020-12-16 11:06:50 -08001700func (ctx *moduleContextImpl) isPreventInstall() bool {
1701 return ctx.mod.Properties.PreventInstall
1702}
1703
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001704func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1705 shared := &ctx.mod.sharedFlags
1706 if shared.flagsMap == nil {
1707 shared.numSharedFlags = 0
1708 shared.flagsMap = make(map[string]string)
1709 }
1710 return shared
1711}
1712
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001713func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1714 return ctx.mod.isCfiAssemblySupportEnabled()
1715}
1716
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001717func (ctx *moduleContextImpl) notInPlatform() bool {
1718 return ctx.mod.NotInPlatform()
1719}
1720
Yu Liu76d94462024-10-31 23:32:36 +00001721func (ctx *moduleContextImpl) getOrCreateMakeVarsInfo() *CcMakeVarsInfo {
1722 if ctx.mod.makeVarsInfo == nil {
1723 ctx.mod.makeVarsInfo = &CcMakeVarsInfo{}
1724 }
1725 return ctx.mod.makeVarsInfo
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
Chris Parsons216e10a2020-07-09 17:12:52 -04001781func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001782 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001783 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001784 }); ok {
1785 return p.dataPaths()
1786 }
1787 return nil
1788}
1789
Ivan Lozanof1868af2022-04-12 13:08:36 -04001790func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001791 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1792 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001793 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001794 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001795 if c.ProductSpecific() {
1796 // If the module is product specific with 'product_specific: true',
1797 // do not add a name suffix because it is a base module.
1798 return ""
1799 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001800 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001801 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001802 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001803 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001804 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001805 // add version suffix only if the module is using different vndk version than the
1806 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001807 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001808 }
1809 return nameSuffix
1810}
1811
Ivan Lozanof1868af2022-04-12 13:08:36 -04001812func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1813 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001814
1815 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001816 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001817 }
1818
Colin Cross127bb8b2020-12-16 16:46:01 -08001819 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001820 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001821 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1822 // added for product variant only when we have vendor and product variants with core
1823 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001824 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001825 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001826 subName += vendorPublicLibrarySuffix
1827 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001828 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1829 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001830 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001831 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001832 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001833 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001834 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001835 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001836 subName += RecoverySuffix
1837 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1838 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001839 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001840 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001841 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001842 } else if c.IsStubs() && c.IsSdkVariant() {
1843 // Public API surface (NDK)
1844 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1845 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001846 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001847
1848 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001849}
1850
Sam Delmerico75dbca22023-04-20 13:13:25 +00001851func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1852 ctx := &moduleContext{
1853 ModuleContext: actx,
1854 moduleContextImpl: moduleContextImpl{
1855 mod: c,
1856 },
1857 }
1858 ctx.ctx = ctx
1859 return ctx
1860}
1861
Spandan Das20fce2d2023-04-12 17:21:39 +00001862// TODO (b/277651159): Remove this allowlist
1863var (
1864 skipStubLibraryMultipleApexViolation = map[string]bool{
1865 "libclang_rt.asan": true,
1866 "libclang_rt.hwasan": true,
1867 // runtime apex
1868 "libc": true,
1869 "libc_hwasan": true,
1870 "libdl_android": true,
1871 "libm": true,
1872 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001873 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001874 // art apex
Martin Stjernholm75598032024-07-12 18:47:26 +01001875 // TODO(b/234351700): Remove this when com.android.art.debug is gone.
Spandan Das20fce2d2023-04-12 17:21:39 +00001876 "libandroidio": true,
1877 "libdexfile": true,
Martin Stjernholm75598032024-07-12 18:47:26 +01001878 "libdexfiled": true, // com.android.art.debug only
Spandan Das20fce2d2023-04-12 17:21:39 +00001879 "libnativebridge": true,
1880 "libnativehelper": true,
1881 "libnativeloader": true,
1882 "libsigchain": true,
1883 }
1884)
1885
1886// Returns true if a stub library could be installed in multiple apexes
1887func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1888 // If this is not an apex variant, no check necessary
1889 if !c.InAnyApex() {
1890 return false
1891 }
1892 // If this is not a stub library, no check necessary
1893 if !c.HasStubsVariants() {
1894 return false
1895 }
1896 // Skip the allowlist
1897 // Use BaseModuleName so that this matches prebuilts.
1898 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1899 return false
1900 }
1901
1902 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1903 // Stub libraries should not have more than one apex_available
1904 if len(aaWithoutTestApexes) > 1 {
1905 return true
1906 }
1907 // Stub libraries should not use the wildcard
1908 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1909 return true
1910 }
1911 // Default: no violation
1912 return false
1913}
1914
Chris Parsons8d6e4332021-02-22 16:13:50 -05001915func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001916 ctx := moduleContextFromAndroidModuleContext(actx, c)
1917
Inseob Kim37e0bb02024-04-29 15:54:44 +09001918 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
1919 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
1920 Logtags: c.logtagsPaths,
1921 })
1922
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001923 // If Test_only is set on a module in bp file, respect the setting, otherwise
1924 // see if is a known test module type.
1925 testOnly := c.testModule || c.testLibrary()
1926 if c.sourceProperties.Test_only != nil {
1927 testOnly = Bool(c.sourceProperties.Test_only)
1928 }
1929 // Keep before any early returns.
1930 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
1931 TestOnly: testOnly,
1932 TopLevelTarget: c.testModule,
1933 })
1934
Ivan Lozanof1868af2022-04-12 13:08:36 -04001935 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08001936 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001937 if !apexInfo.IsForPlatform() {
1938 c.hideApexVariantFromMake = true
1939 }
1940
Chris Parsonseefc9e62021-04-02 17:36:47 -04001941 c.makeLinkType = GetMakeLinkType(actx, c)
1942
Colin Crossf18e1102017-11-16 14:33:08 -08001943 deps := c.depsToPaths(ctx)
1944 if ctx.Failed() {
1945 return
1946 }
1947
Joe Onorato37f900c2023-07-18 16:58:16 -07001948 for _, generator := range c.generators {
1949 gen := generator.GeneratorSources(ctx)
1950 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
1951 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
1952 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
1953 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
1954 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
1955 if len(deps.Objs.objFiles) == 0 {
1956 // If we are reusuing object files (which happens when we're a shared library and we're
1957 // reusing our static variant's object files), then skip adding the actual source files,
1958 // because we already have the object for it.
1959 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
1960 }
1961 }
1962
1963 if ctx.Failed() {
1964 return
1965 }
1966
Spandan Das20fce2d2023-04-12 17:21:39 +00001967 if c.stubLibraryMultipleApexViolation(actx) {
1968 actx.PropertyErrorf("apex_available",
1969 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
1970 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001971 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1972 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001973 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1974 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001975 }
1976
Colin Crossca860ac2016-01-04 14:34:37 -08001977 flags := Flags{
1978 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001979 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001980 }
Joe Onorato37f900c2023-07-18 16:58:16 -07001981 for _, generator := range c.generators {
1982 flags = generator.GeneratorFlags(ctx, flags, deps)
1983 }
Colin Crossca860ac2016-01-04 14:34:37 -08001984 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001985 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001986 }
1987 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001988 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001989 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001990 if c.stl != nil {
1991 flags = c.stl.flags(ctx, flags)
1992 }
Colin Cross16b23492016-01-06 14:41:07 -08001993 if c.sanitize != nil {
1994 flags = c.sanitize.flags(ctx, flags)
1995 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001996 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001997 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001998 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001999 if c.fuzzer != nil {
2000 flags = c.fuzzer.flags(ctx, flags)
2001 }
Stephen Craneba090d12017-05-09 15:44:35 -07002002 if c.lto != nil {
2003 flags = c.lto.flags(ctx, flags)
2004 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002005 if c.afdo != nil {
2006 flags = c.afdo.flags(ctx, flags)
2007 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002008 if c.orderfile != nil {
2009 flags = c.orderfile.flags(ctx, flags)
2010 }
Colin Crossca860ac2016-01-04 14:34:37 -08002011 for _, feature := range c.features {
2012 flags = feature.flags(ctx, flags)
2013 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002014 if ctx.Failed() {
2015 return
2016 }
2017
Colin Cross4af21ed2019-11-04 09:37:55 -08002018 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2019 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2020 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002021
Colin Cross4af21ed2019-11-04 09:37:55 -08002022 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002023
2024 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002025 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002026 }
2027 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002028 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002029 }
2030
Colin Cross3e5e7782022-06-17 22:17:05 +00002031 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2032
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002033 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002034 // We need access to all the flags seen by a source file.
2035 if c.sabi != nil {
2036 flags = c.sabi.flags(ctx, flags)
2037 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002038
Colin Cross4af21ed2019-11-04 09:37:55 -08002039 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002040
Joe Onorato37f900c2023-07-18 16:58:16 -07002041 for _, generator := range c.generators {
2042 generator.GeneratorBuildActions(ctx, flags, deps)
2043 }
2044
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002045 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002046 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002047 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002048 if ctx.Failed() {
2049 return
2050 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002051 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002052 c.objFiles = objs.objFiles
2053 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002054 }
2055
Colin Crossca860ac2016-01-04 14:34:37 -08002056 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002057 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002058 if ctx.Failed() {
2059 return
2060 }
Colin Cross635c3b02016-05-18 15:37:25 -07002061 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002062
Chris Parsons94a0bba2021-06-04 15:03:47 -04002063 c.maybeUnhideFromMake()
Colin Crossce75d2c2016-10-06 16:12:58 -07002064 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002065
Colin Cross40213022023-12-13 15:19:49 -08002066 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002067
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002068 if Bool(c.Properties.Cmake_snapshot_supported) {
2069 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2070 }
2071
Chris Parsons94a0bba2021-06-04 15:03:47 -04002072 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002073
2074 if c.linker != nil {
2075 moduleInfoJSON := ctx.ModuleInfoJSON()
2076 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2077 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2078 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2079 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2080 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2081
2082 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2083 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2084 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2085 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2086
2087 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2088 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2089 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2090 moduleInfoJSON.SubName += ".cfi"
2091 }
2092 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2093 moduleInfoJSON.SubName += ".hwasan"
2094 }
2095 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2096 moduleInfoJSON.SubName += ".scs"
2097 }
2098 }
2099 moduleInfoJSON.SubName += c.Properties.SubName
2100
2101 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2102 moduleInfoJSON.Uninstallable = true
2103 }
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002104 }
Wei Lia1aa2972024-06-21 13:08:51 -07002105
2106 buildComplianceMetadataInfo(ctx, c, deps)
mrziwangabdb2932024-06-18 12:43:41 -07002107
Cole Faust96a692b2024-08-08 14:47:51 -07002108 if b, ok := c.compiler.(*baseCompiler); ok {
2109 c.hasAidl = b.hasSrcExt(ctx, ".aidl")
2110 c.hasLex = b.hasSrcExt(ctx, ".l") || b.hasSrcExt(ctx, ".ll")
2111 c.hasProto = b.hasSrcExt(ctx, ".proto")
2112 c.hasRenderscript = b.hasSrcExt(ctx, ".rscript") || b.hasSrcExt(ctx, ".fs")
2113 c.hasSysprop = b.hasSrcExt(ctx, ".sysprop")
2114 c.hasWinMsg = b.hasSrcExt(ctx, ".mc")
2115 c.hasYacc = b.hasSrcExt(ctx, ".y") || b.hasSrcExt(ctx, ".yy")
2116 }
2117
mrziwangabdb2932024-06-18 12:43:41 -07002118 c.setOutputFiles(ctx)
Yu Liu76d94462024-10-31 23:32:36 +00002119
2120 if c.makeVarsInfo != nil {
2121 android.SetProvider(ctx, CcMakeVarsInfoProvider, c.makeVarsInfo)
2122 }
mrziwangabdb2932024-06-18 12:43:41 -07002123}
2124
2125func (c *Module) setOutputFiles(ctx ModuleContext) {
2126 if c.outputFile.Valid() {
2127 ctx.SetOutputFiles(android.Paths{c.outputFile.Path()}, "")
2128 } else {
2129 ctx.SetOutputFiles(android.Paths{}, "")
2130 }
2131 if c.linker != nil {
2132 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), "unstripped")
2133 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), "stripped_all")
2134 }
Wei Lia1aa2972024-06-21 13:08:51 -07002135}
2136
2137func buildComplianceMetadataInfo(ctx ModuleContext, c *Module, deps PathDeps) {
2138 // Dump metadata that can not be done in android/compliance-metadata.go
2139 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
2140 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.IS_STATIC_LIB, strconv.FormatBool(ctx.static()))
2141 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.BUILT_FILES, c.outputFile.String())
2142
2143 // Static deps
2144 staticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(false))
2145 staticDepNames := make([]string, 0, len(staticDeps))
2146 for _, dep := range staticDeps {
2147 staticDepNames = append(staticDepNames, dep.Name())
2148 }
2149
2150 staticDepPaths := make([]string, 0, len(deps.StaticLibs))
2151 for _, dep := range deps.StaticLibs {
2152 staticDepPaths = append(staticDepPaths, dep.String())
2153 }
2154 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEPS, android.FirstUniqueStrings(staticDepNames))
2155 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEP_FILES, android.FirstUniqueStrings(staticDepPaths))
2156
2157 // Whole static deps
2158 wholeStaticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(true))
2159 wholeStaticDepNames := make([]string, 0, len(wholeStaticDeps))
2160 for _, dep := range wholeStaticDeps {
2161 wholeStaticDepNames = append(wholeStaticDepNames, dep.Name())
2162 }
2163
2164 wholeStaticDepPaths := make([]string, 0, len(deps.WholeStaticLibs))
2165 for _, dep := range deps.WholeStaticLibs {
2166 wholeStaticDepPaths = append(wholeStaticDepPaths, dep.String())
2167 }
2168 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEPS, android.FirstUniqueStrings(wholeStaticDepNames))
2169 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEP_FILES, android.FirstUniqueStrings(wholeStaticDepPaths))
Chris Parsons94a0bba2021-06-04 15:03:47 -04002170}
2171
2172func (c *Module) maybeUnhideFromMake() {
2173 // If a lib is directly included in any of the APEXes or is not available to the
2174 // platform (which is often the case when the stub is provided as a prebuilt),
2175 // unhide the stubs variant having the latest version gets visible to make. In
2176 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2177 // force anything in the make world to link against the stubs library. (unless it
2178 // is explicitly referenced via .bootstrap suffix or the module is marked with
2179 // 'bootstrap: true').
2180 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002181 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002182 c.IsStubs() && !c.InVendorRamdisk() {
2183 c.Properties.HideFromMake = false // unhide
2184 // Note: this is still non-installable
2185 }
2186}
2187
Colin Cross8ff10582023-12-07 13:10:56 -08002188// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2189// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002190func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002191 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002192 // If the module has been specifically configure to not be installed then
2193 // hide from make as otherwise it will break when running inside make
2194 // as the output path to install will not be specified. Not all uninstallable
2195 // modules can be hidden from make as some are needed for resolving make side
2196 // dependencies.
2197 c.HideFromMake()
Spandan Das034af2c2024-10-30 21:45:09 +00002198 c.SkipInstall()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002199 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002200 c.SkipInstall()
2201 }
2202
2203 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2204 // to allow using the outputs in a genrule.
2205 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002206 c.installer.install(ctx, c.outputFile.Path())
2207 if ctx.Failed() {
2208 return
Colin Crossca860ac2016-01-04 14:34:37 -08002209 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002210 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002211}
2212
Colin Cross0ea8ba82019-06-06 14:33:29 -07002213func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002214 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002215 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002216 }
Colin Crossca860ac2016-01-04 14:34:37 -08002217 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002218}
2219
Colin Crossca860ac2016-01-04 14:34:37 -08002220func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002221 for _, generator := range c.generators {
2222 generator.GeneratorInit(ctx)
2223 }
Colin Crossca860ac2016-01-04 14:34:37 -08002224 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002225 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002226 }
Colin Crossca860ac2016-01-04 14:34:37 -08002227 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002228 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002229 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002230 if c.stl != nil {
2231 c.stl.begin(ctx)
2232 }
Colin Cross16b23492016-01-06 14:41:07 -08002233 if c.sanitize != nil {
2234 c.sanitize.begin(ctx)
2235 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002236 if c.coverage != nil {
2237 c.coverage.begin(ctx)
2238 }
Yi Kong9723e332023-12-04 14:52:53 +09002239 if c.afdo != nil {
2240 c.afdo.begin(ctx)
2241 }
Stephen Craneba090d12017-05-09 15:44:35 -07002242 if c.lto != nil {
2243 c.lto.begin(ctx)
2244 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002245 if c.orderfile != nil {
2246 c.orderfile.begin(ctx)
2247 }
Dan Albert92fe7402020-07-15 13:33:30 -07002248 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002249 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002250 if err != nil {
2251 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002252 c.Properties.Sdk_version = nil
2253 } else {
2254 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002255 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002256 }
Colin Crossca860ac2016-01-04 14:34:37 -08002257}
2258
Colin Cross37047f12016-12-13 17:06:13 -08002259func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002260 deps := Deps{}
2261
Joe Onorato37f900c2023-07-18 16:58:16 -07002262 for _, generator := range c.generators {
2263 deps = generator.GeneratorDeps(ctx, deps)
2264 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002265 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002266 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002267 }
2268 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002269 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002270 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002271 if c.stl != nil {
2272 deps = c.stl.deps(ctx, deps)
2273 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002274 if c.coverage != nil {
2275 deps = c.coverage.deps(ctx, deps)
2276 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002277
Colin Crossb6715442017-10-24 11:13:31 -07002278 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2279 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2280 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2281 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2282 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2283 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002284 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002285 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002286
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002287 for _, lib := range deps.ReexportSharedLibHeaders {
2288 if !inList(lib, deps.SharedLibs) {
2289 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2290 }
2291 }
2292
2293 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002294 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2295 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 -07002296 }
2297 }
2298
Colin Cross5950f382016-12-13 12:50:57 -08002299 for _, lib := range deps.ReexportHeaderLibHeaders {
2300 if !inList(lib, deps.HeaderLibs) {
2301 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2302 }
2303 }
2304
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002305 for _, gen := range deps.ReexportGeneratedHeaders {
2306 if !inList(gen, deps.GeneratedHeaders) {
2307 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2308 }
2309 }
2310
Colin Crossc99deeb2016-04-11 15:06:20 -07002311 return deps
2312}
2313
Dan Albert7e9d2952016-08-04 13:02:36 -07002314func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002315 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002316 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002317 moduleContextImpl: moduleContextImpl{
2318 mod: c,
2319 },
2320 }
2321 ctx.ctx = ctx
2322
Colin Crossca860ac2016-01-04 14:34:37 -08002323 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002324}
2325
Jiyong Park7ed9de32018-10-15 22:25:07 +09002326// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002327func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002328 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2329 version := name[sharp+1:]
2330 libname := name[:sharp]
2331 return libname, version
2332 }
2333 return name, ""
2334}
2335
Dan Albert92fe7402020-07-15 13:33:30 -07002336func GetCrtVariations(ctx android.BottomUpMutatorContext,
2337 m LinkableInterface) []blueprint.Variation {
2338 if ctx.Os() != android.Android {
2339 return nil
2340 }
2341 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002342 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2343 minSdkVersion := m.MinSdkVersion()
2344 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2345 minSdkVersion = m.SdkVersion()
2346 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002347 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2348 if err != nil {
2349 ctx.PropertyErrorf("min_sdk_version", err.Error())
2350 }
Colin Cross363ec762023-01-13 13:45:14 -08002351
2352 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002353 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002354 if apiLevel.LessThan(minApiForArch) {
2355 apiLevel = minApiForArch
2356 }
2357
Dan Albert92fe7402020-07-15 13:33:30 -07002358 return []blueprint.Variation{
2359 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002360 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002361 }
2362 }
2363 return []blueprint.Variation{
2364 {Mutator: "sdk", Variation: ""},
2365 }
2366}
2367
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002368func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2369 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002370
2371 variations = append([]blueprint.Variation(nil), variations...)
2372
Liz Kammer23942242022-04-08 15:41:00 -04002373 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002374 // Version is explicitly specified. i.e. libFoo#30
2375 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002376 if tag, ok := depTag.(libraryDependencyTag); ok {
2377 tag.explicitlyVersioned = true
Colin Crossafcdce82024-10-22 13:59:33 -07002378 // depTag is an interface that contains a concrete non-pointer struct. That makes the local
2379 // tag variable a copy of the contents of depTag, and updating it doesn't change depTag. Reassign
2380 // the modified copy to depTag.
2381 depTag = tag
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002382 } else {
2383 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2384 }
Colin Crosse7257d22020-09-24 09:56:18 -07002385 }
Colin Crosse7257d22020-09-24 09:56:18 -07002386
Colin Cross0de8a1e2020-09-18 14:15:30 -07002387 if far {
2388 ctx.AddFarVariationDependencies(variations, depTag, name)
2389 } else {
2390 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002391 }
2392}
2393
Kiyoung Kim487689e2022-07-26 09:48:22 +09002394func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2395 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002396 return snapshot
2397 }
2398
2399 return lib
2400}
2401
Kiyoung Kim37693d02024-04-04 09:56:15 +09002402// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002403// of names:
2404//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002405// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002406//
2407// For each of these, it adds the name of the ndk_library module to the list of
2408// variant libs.
2409//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002410// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002411//
2412// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002413//
2414// The caller can then know to add the variantLibs dependencies differently from the
2415// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002416func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002417 variantLibs = []string{}
2418
2419 nonvariantLibs = []string{}
2420 for _, entry := range list {
2421 // strip #version suffix out
2422 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002423 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002424 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002425 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002426 nonvariantLibs = append(nonvariantLibs, entry)
2427 }
2428 }
2429 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002430
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002431}
2432
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002433func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2434 nonVariantLibs := []string{}
2435 variantLibs := []string{}
2436
2437 for _, lib := range libs {
2438 replaceLibName := GetReplaceModuleName(lib, replaceList)
2439 if replaceLibName == lib {
2440 // Do not handle any libs which are not in API imports
2441 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2442 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2443 variantLibs = append(variantLibs, replaceLibName)
2444 } else {
2445 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2446 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002447 }
2448
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002449 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002450}
2451
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002452func (c *Module) shouldUseApiSurface() bool {
2453 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2454 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2455 // LLNDK Variant
2456 return true
2457 }
2458
2459 if c.Properties.IsSdkVariant {
2460 // NDK Variant
2461 return true
2462 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002463 }
2464
2465 return false
2466}
2467
Colin Cross1e676be2016-10-12 14:38:15 -07002468func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002469 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002470 return
2471 }
2472
Colin Cross37047f12016-12-13 17:06:13 -08002473 ctx := &depsContext{
2474 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002475 moduleContextImpl: moduleContextImpl{
2476 mod: c,
2477 },
2478 }
2479 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002480
Colin Crossc99deeb2016-04-11 15:06:20 -07002481 deps := c.deps(ctx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002482
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002483 apiNdkLibs := []string{}
2484 apiLateNdkLibs := []string{}
2485
Yo Chiang219968c2020-09-22 18:45:04 +08002486 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2487
Dan Albert914449f2016-06-17 16:45:24 -07002488 variantNdkLibs := []string{}
2489 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002490 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002491 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2492 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2493 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002494 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002495
Colin Cross32ec36c2016-12-15 07:39:51 -08002496 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002497 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002498 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002499 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002500 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002501
Spandan Das73bcafc2022-08-18 23:26:00 +00002502 if c.isNDKStubLibrary() {
Jiyong Parkf8fab9b2024-09-02 15:24:15 +09002503 variationExists := actx.OtherModuleDependencyVariantExists(nil, lib)
2504 if variationExists {
2505 actx.AddVariationDependencies(nil, depTag, lib)
2506 } else {
2507 // dependencies to ndk_headers fall here as ndk_headers do not have
2508 // any variants.
2509 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
2510 }
Spandan Dasff665182024-09-11 18:48:44 +00002511 } else if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002512 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002513 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002514 } else {
2515 actx.AddVariationDependencies(nil, depTag, lib)
2516 }
2517 }
2518
Dan Albertf1d14c72020-07-30 14:32:55 -07002519 if c.isNDKStubLibrary() {
2520 // NDK stubs depend on their implementation because the ABI dumps are
2521 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002522
Spandan Das8b08aea2023-03-14 19:29:34 +00002523 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2524 c.ImageVariation(),
2525 blueprint.Variation{Mutator: "link", Variation: "shared"},
2526 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002527 }
2528
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002529 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2530 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2531 c.Target().NativeBridge == android.NativeBridgeDisabled {
2532 actx.AddVariationDependencies(
Jihoon Kang47e91842024-06-19 00:51:16 +00002533 []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}},
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002534 llndkHeaderLibTag,
2535 deps.LlndkHeaderLibs...)
2536 }
2537
Jiyong Park5d1598f2019-02-25 22:14:17 +09002538 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002539 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002540
Jiyong Park5d1598f2019-02-25 22:14:17 +09002541 actx.AddVariationDependencies([]blueprint.Variation{
2542 {Mutator: "link", Variation: "static"},
2543 }, depTag, lib)
2544 }
2545
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002546 for _, lib := range deps.StaticLibs {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002547 // Some dependencies listed in static_libs might actually be rust_ffi rlib variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002548 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002549
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002550 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002551 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002552 }
Jiyong Parke3867542020-12-03 17:28:25 +09002553 if inList(lib, deps.ExcludeLibsForApex) {
2554 depTag.excludeInApex = true
2555 }
Dan Willemsen59339a22018-07-22 21:18:45 -07002556 actx.AddVariationDependencies([]blueprint.Variation{
2557 {Mutator: "link", Variation: "static"},
2558 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002559 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002560
Jooyung Han75568392020-03-20 04:29:24 +09002561 // staticUnwinderDep is treated as staticDep for Q apexes
2562 // so that native libraries/binaries are linked with static unwinder
2563 // because Q libc doesn't have unwinder APIs
2564 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002565 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002566 actx.AddVariationDependencies([]blueprint.Variation{
2567 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002568 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002569 }
2570
Jiyong Park7ed9de32018-10-15 22:25:07 +09002571 // shared lib names without the #version suffix
2572 var sharedLibNames []string
2573
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002574 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002575 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002576 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002577 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002578 }
Jiyong Parke3867542020-12-03 17:28:25 +09002579 if inList(lib, deps.ExcludeLibsForApex) {
2580 depTag.excludeInApex = true
2581 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002582 if inList(lib, deps.ExcludeLibsForNonApex) {
2583 depTag.excludeInNonApex = true
2584 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002585
Jiyong Park73c54ee2019-10-22 20:31:18 +09002586 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002587 sharedLibNames = append(sharedLibNames, name)
2588
Colin Crosse7257d22020-09-24 09:56:18 -07002589 variations := []blueprint.Variation{
2590 {Mutator: "link", Variation: "shared"},
2591 }
Spandan Dasff665182024-09-11 18:48:44 +00002592 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002593 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002594
Colin Crossfe9acfe2021-06-14 16:13:03 -07002595 for _, lib := range deps.LateStaticLibs {
2596 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2597 actx.AddVariationDependencies([]blueprint.Variation{
2598 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002599 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002600 }
2601
Colin Cross3e5e7782022-06-17 22:17:05 +00002602 for _, lib := range deps.UnexportedStaticLibs {
2603 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2604 actx.AddVariationDependencies([]blueprint.Variation{
2605 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002606 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002607 }
2608
Jiyong Park7ed9de32018-10-15 22:25:07 +09002609 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002610 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002611 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2612 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2613 // linking against both the stubs lib and the non-stubs lib at the same time.
2614 continue
2615 }
Colin Cross6e511a92020-07-27 21:26:48 -07002616 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002617 variations := []blueprint.Variation{
2618 {Mutator: "link", Variation: "shared"},
2619 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002620 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002621 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002622
Dan Willemsen59339a22018-07-22 21:18:45 -07002623 actx.AddVariationDependencies([]blueprint.Variation{
2624 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002625 }, dataLibDepTag, deps.DataLibs...)
2626
Colin Crossc8caa062021-09-24 16:50:14 -07002627 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2628
Chris Parsons79d66a52020-06-05 17:26:16 -04002629 actx.AddVariationDependencies([]blueprint.Variation{
2630 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002631 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002632
Colin Cross68861832016-07-08 10:41:41 -07002633 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002634
2635 for _, gen := range deps.GeneratedHeaders {
2636 depTag := genHeaderDepTag
2637 if inList(gen, deps.ReexportGeneratedHeaders) {
2638 depTag = genHeaderExportDepTag
2639 }
2640 actx.AddDependency(c, depTag, gen)
2641 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002642
Cole Faust65cb40a2024-10-21 15:41:42 -07002643 for _, gen := range deps.DeviceFirstGeneratedHeaders {
2644 depTag := genHeaderDepTag
2645 actx.AddVariationDependencies(ctx.Config().AndroidFirstDeviceTarget.Variations(), depTag, gen)
2646 }
2647
Dan Albert92fe7402020-07-15 13:33:30 -07002648 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002649 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002650 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002651 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002652 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002653 }
Colin Crossc465efd2021-06-11 18:00:04 -07002654 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002655 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002656 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002657 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002658 if deps.DynamicLinker != "" {
2659 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002660 }
Dan Albert914449f2016-06-17 16:45:24 -07002661
2662 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002663
2664 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002665 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002666 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002667 {Mutator: "link", Variation: "shared"},
2668 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002669 actx.AddVariationDependencies([]blueprint.Variation{
2670 {Mutator: "version", Variation: version},
2671 {Mutator: "link", Variation: "shared"},
2672 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002673
2674 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002675 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002676 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002677 {Mutator: "link", Variation: "shared"},
2678 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002679 actx.AddVariationDependencies([]blueprint.Variation{
2680 {Mutator: "version", Variation: version},
2681 {Mutator: "link", Variation: "shared"},
2682 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002683
Vinh Tran367d89d2023-04-28 11:21:25 -04002684 if len(deps.AidlLibs) > 0 {
2685 actx.AddDependency(
2686 c,
2687 aidlLibraryTag,
2688 deps.AidlLibs...,
2689 )
2690 }
2691
Colin Cross6362e272015-10-29 15:25:03 -07002692}
Colin Cross21b9a242015-03-24 14:15:58 -07002693
Colin Crosse40b4ea2018-10-02 22:25:58 -07002694func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002695 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002696 c.beginMutator(ctx)
2697 }
2698}
2699
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002700// Whether a module can link to another module, taking into
2701// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002702func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002703 tag blueprint.DependencyTag) {
2704
2705 switch t := tag.(type) {
2706 case dependencyTag:
2707 if t != vndkExtDepTag {
2708 return
2709 }
2710 case libraryDependencyTag:
2711 default:
2712 return
2713 }
2714
Ivan Lozanof9e21722020-12-02 09:00:51 -05002715 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002716 // Host code is not restricted
2717 return
2718 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002719
Ivan Lozano52767be2019-10-18 14:49:46 -07002720 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002721 // Platform code can link to anything
2722 return
2723 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002724 if from.InRamdisk() {
2725 // Ramdisk code is not NDK
2726 return
2727 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002728 if from.InVendorRamdisk() {
2729 // Vendor ramdisk code is not NDK
2730 return
2731 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002732 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002733 // Recovery code is not NDK
2734 return
2735 }
Colin Cross31076b32020-10-23 17:22:06 -07002736 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002737 if c.StubDecorator() {
2738 // These aren't real libraries, but are the stub shared libraries that are included in
2739 // the NDK.
2740 return
2741 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002742 }
Logan Chien834b9a62019-01-14 15:39:03 +08002743
Ivan Lozano52767be2019-10-18 14:49:46 -07002744 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002745 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2746 // to link to libc++ (non-NDK and without sdk_version).
2747 return
2748 }
2749
Ivan Lozano52767be2019-10-18 14:49:46 -07002750 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002751 // NDK code linking to platform code is never okay.
2752 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002753 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002754 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002755 }
2756
2757 // At this point we know we have two NDK libraries, but we need to
2758 // check that we're not linking against anything built against a higher
2759 // API level, as it is only valid to link against older or equivalent
2760 // APIs.
2761
Inseob Kim01a28722018-04-11 09:48:45 +09002762 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002763 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002764 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002765 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002766 // Current can't be linked against by anything else.
2767 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002768 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002769 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002770 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002771 if err != nil {
2772 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002773 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002774 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002775 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002776 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002777 if err != nil {
2778 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002779 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002780 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002781 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002782
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002783 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002784 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002785 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002786 }
2787 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002788 }
Dan Albert202fe492017-12-15 13:56:59 -08002789
2790 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002791 fromStl := from.SelectedStl()
2792 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002793 if fromStl == "" || toStl == "" {
2794 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002795 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002796 // We can be permissive with the system "STL" since it is only the C++
2797 // ABI layer, but in the future we should make sure that everyone is
2798 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002799 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002800 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002801 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2802 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002803 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002804}
2805
Jooyung Han479ca172020-10-19 18:51:07 +09002806func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2807 if c, ok := ctx.Module().(*Module); ok {
2808 ctx.VisitDirectDeps(func(dep android.Module) {
2809 depTag := ctx.OtherModuleDependencyTag(dep)
2810 ccDep, ok := dep.(LinkableInterface)
2811 if ok {
2812 checkLinkType(ctx, c, ccDep, depTag)
2813 }
2814 })
2815 }
2816}
2817
Jiyong Park5fb8c102018-04-09 12:03:06 +09002818// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002819// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2820// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002821// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Colin Crossda279cf2024-09-17 14:25:45 -07002822func checkDoubleLoadableLibraries(ctx android.BottomUpMutatorContext) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002823 check := func(child, parent android.Module) bool {
2824 to, ok := child.(*Module)
2825 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002826 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002827 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002828
Jooyung Hana70f0672019-01-18 15:20:43 +09002829 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2830 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002831 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002832
Jiyong Park0474e1f2021-01-14 14:26:06 +09002833 // These dependencies are not excercised at runtime. Tracking these will give us
2834 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002835 depTag := ctx.OtherModuleDependencyTag(child)
2836 if IsHeaderDepTag(depTag) {
2837 return false
2838 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002839 if depTag == staticVariantTag {
2840 return false
2841 }
2842 if depTag == stubImplDepTag {
2843 return false
2844 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002845 if depTag == android.RequiredDepTag {
2846 return false
2847 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002848
Justin Yun63e9ec72020-10-29 16:49:43 +09002849 // Even if target lib has no vendor variant, keep checking dependency
2850 // graph in case it depends on vendor_available or product_available
2851 // but not double_loadable transtively.
2852 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002853 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002854 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002855
Jiyong Park0474e1f2021-01-14 14:26:06 +09002856 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2857 // one.
2858 if Bool(to.VendorProperties.Double_loadable) {
2859 return true
2860 }
2861
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002862 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002863 return false
2864 }
2865
Jooyung Hana70f0672019-01-18 15:20:43 +09002866 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2867 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002868 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002869 return false
2870 }
2871 if module, ok := ctx.Module().(*Module); ok {
2872 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002873 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002874 ctx.WalkDeps(check)
2875 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002876 }
2877 }
2878}
2879
Yu Liue4312402023-01-18 09:15:31 -08002880func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2881 // For the dependency from platform to apex, use the latest stubs
2882 apexSdkVersion := android.FutureApiLevel
2883 if !apexInfo.IsForPlatform() {
2884 apexSdkVersion = apexInfo.MinSdkVersion
2885 }
2886
2887 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2888 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2889 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2890 // (b/144430859)
2891 apexSdkVersion = android.FutureApiLevel
2892 }
2893
2894 return apexSdkVersion
2895}
2896
Colin Crossc99deeb2016-04-11 15:06:20 -07002897// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002898func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002899 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002900
Colin Cross0de8a1e2020-09-18 14:15:30 -07002901 var directStaticDeps []StaticLibraryInfo
2902 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002903
Colin Cross0de8a1e2020-09-18 14:15:30 -07002904 reexportExporter := func(exporter FlagExporterInfo) {
2905 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2906 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2907 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2908 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2909 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002910 }
2911
Colin Crossff694a82023-12-13 15:54:49 -08002912 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002913 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002914
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002915 skipModuleList := map[string]bool{}
2916
Colin Crossd11fcda2017-10-23 17:59:01 -07002917 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002918 depName := ctx.OtherModuleName(dep)
2919 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002920
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002921 if _, ok := skipModuleList[depName]; ok {
2922 // skip this module because original module or API imported module matching with this should be used instead.
2923 return
2924 }
2925
Dan Willemsen47450072021-10-19 20:24:49 -07002926 if depTag == android.DarwinUniversalVariantTag {
2927 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2928 return
2929 }
2930
Vinh Tran367d89d2023-04-28 11:21:25 -04002931 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08002932 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04002933 depPaths.AidlLibraryInfos = append(
2934 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08002935 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04002936 )
2937 }
2938 }
2939
Ivan Lozano52767be2019-10-18 14:49:46 -07002940 ccDep, ok := dep.(LinkableInterface)
2941 if !ok {
2942
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002943 // handling for a few module types that aren't cc Module but that are also supported
2944 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002945 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002946 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002947 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2948 genRule.GeneratedSourceFiles()...)
2949 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002950 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002951 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002952 // Support exported headers from a generated_sources dependency
2953 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002954 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002955 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002956 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002957 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002958 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002959 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002960 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002961 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002962 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2963 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002964 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002965 // 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 +09002966 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002967
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002968 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002969 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002970 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002971 }
Colin Crosscef792e2021-06-11 18:01:26 -07002972 case CrtBeginDepTag:
2973 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2974 case CrtEndDepTag:
2975 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002976 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002977 return
2978 }
2979
Colin Crossfe17f6f2019-03-28 19:30:56 -07002980 if depTag == android.ProtoPluginDepTag {
2981 return
2982 }
2983
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002984 if depTag == android.RequiredDepTag {
2985 return
2986 }
2987
Colin Crossd11fcda2017-10-23 17:59:01 -07002988 if dep.Target().Os != ctx.Os() {
Steven Morelandaaae81f2024-08-27 22:55:48 +00002989 ctx.ModuleErrorf("OS mismatch between %q (%s) and %q (%s)", ctx.ModuleName(), ctx.Os().Name, depName, dep.Target().Os.Name)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002990 return
2991 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002992 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002993 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2994 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002995 return
2996 }
2997
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002998 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002999 // Skip reused objects for stub libraries, they use their own stub object file instead.
3000 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3001 // version mutator, so the stubs variant is created from the shared variant that
3002 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003003 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003004 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003005 objs := staticAnalogue.ReuseObjects
3006 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003007 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003008 reexportExporter(depExporterInfo)
3009 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003010 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003011 }
3012
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08003013 if depTag == llndkHeaderLibTag {
3014 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3015 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
3016 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3017 }
3018
Colin Cross6e511a92020-07-27 21:26:48 -07003019 linkFile := ccDep.OutputFile()
3020
3021 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3022 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003023 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003024 return
3025 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003026
Jiyong Parke3867542020-12-03 17:28:25 +09003027 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3028 return
3029 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003030 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3031 return
3032 }
Jiyong Parke3867542020-12-03 17:28:25 +09003033
Colin Cross313aa542023-12-13 13:47:44 -08003034 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003035
Colin Cross6e511a92020-07-27 21:26:48 -07003036 var ptr *android.Paths
3037 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003038
Colin Cross6e511a92020-07-27 21:26:48 -07003039 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003040
Colin Cross6e511a92020-07-27 21:26:48 -07003041 switch {
3042 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003043 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003044 if !ctx.Config().AllowMissingDependencies() {
3045 ctx.ModuleErrorf("module %q is not a header library", depName)
3046 } else {
3047 ctx.AddMissingDependencies([]string{depName})
3048 }
3049 return
3050 }
Colin Cross6e511a92020-07-27 21:26:48 -07003051 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003052 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003053 if !ctx.Config().AllowMissingDependencies() {
3054 ctx.ModuleErrorf("module %q is not a shared library", depName)
3055 } else {
3056 ctx.AddMissingDependencies([]string{depName})
3057 }
3058 return
3059 }
Jiyong Parke3867542020-12-03 17:28:25 +09003060
Jiyong Park7d55b612021-06-11 17:22:09 +09003061 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3062 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003063
Jiyong Park1ad8e162020-12-01 23:40:09 +09003064 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3065 // linkFile, depFile, and ptr.
3066 if c.IsStubs() {
3067 break
3068 }
3069
Colin Cross0de8a1e2020-09-18 14:15:30 -07003070 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3071 depFile = sharedLibraryInfo.TableOfContents
3072
Colin Cross6e511a92020-07-27 21:26:48 -07003073 ptr = &depPaths.SharedLibs
3074 switch libDepTag.Order {
3075 case earlyLibraryDependency:
3076 ptr = &depPaths.EarlySharedLibs
3077 depPtr = &depPaths.EarlySharedLibsDeps
3078 case normalLibraryDependency:
3079 ptr = &depPaths.SharedLibs
3080 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003081 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003082 case lateLibraryDependency:
3083 ptr = &depPaths.LateSharedLibs
3084 depPtr = &depPaths.LateSharedLibsDeps
3085 default:
3086 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003087 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003088
Colin Cross6e511a92020-07-27 21:26:48 -07003089 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003090 if ccDep.RustLibraryInterface() {
3091 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3092 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3093 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3094 if libDepTag.wholeStatic {
3095 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3096 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
Jiyong Park1ad8e162020-12-01 23:40:09 +09003097
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003098 // If whole_static, track this as we want to make sure that in a final linkage for a shared library,
3099 // exported functions from the rust generated staticlib still exported.
3100 if c.CcLibrary() && c.Shared() {
3101 c.WholeRustStaticlib = true
3102 }
Colin Cross6e511a92020-07-27 21:26:48 -07003103 }
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003104
Colin Cross6e511a92020-07-27 21:26:48 -07003105 } else {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003106 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3107 if !isStaticLib {
3108 if !ctx.Config().AllowMissingDependencies() {
3109 ctx.ModuleErrorf("module %q is not a static library", depName)
3110 } else {
3111 ctx.AddMissingDependencies([]string{depName})
3112 }
3113 return
Inseob Kimeec88e12020-01-22 11:11:29 +09003114 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003115
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003116 // Stubs lib doesn't link to the static lib dependencies. Don't set
3117 // linkFile, depFile, and ptr.
3118 if c.IsStubs() {
3119 break
3120 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003121
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003122 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
3123 if libDepTag.wholeStatic {
3124 ptr = &depPaths.WholeStaticLibs
3125 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3126 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
3127 } else {
3128 // This case normally catches prebuilt static
3129 // libraries, but it can also occur when
3130 // AllowMissingDependencies is on and the
3131 // dependencies has no sources of its own
3132 // but has a whole_static_libs dependency
3133 // on a missing library. We want to depend
3134 // on the .a file so that there is something
3135 // in the dependency tree that contains the
3136 // error rule for the missing transitive
3137 // dependency.
3138 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
3139 }
3140 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3141 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
3142 } else {
3143 switch libDepTag.Order {
3144 case earlyLibraryDependency:
3145 panic(fmt.Errorf("early static libs not supported"))
3146 case normalLibraryDependency:
3147 // static dependencies will be handled separately so they can be ordered
3148 // using transitive dependencies.
3149 ptr = nil
3150 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
3151 case lateLibraryDependency:
3152 ptr = &depPaths.LateStaticLibs
3153 default:
3154 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
3155 }
3156 }
3157
3158 // Collect any exported Rust rlib deps from static libraries which have been included as whole_static_libs
3159 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3160
3161 if libDepTag.unexportedSymbols {
3162 depPaths.LdFlags = append(depPaths.LdFlags,
3163 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3164 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003165 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003166 }
3167
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003168 if libDepTag.static() && !libDepTag.wholeStatic && !ccDep.RustLibraryInterface() {
Colin Cross6e511a92020-07-27 21:26:48 -07003169 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3170 ctx.ModuleErrorf("module %q not a static library", depName)
3171 return
3172 }
Logan Chien43d34c32017-12-20 01:17:32 +08003173
Colin Cross6e511a92020-07-27 21:26:48 -07003174 // When combining coverage files for shared libraries and executables, coverage files
3175 // in static libraries act as if they were whole static libraries. The same goes for
3176 // source based Abi dump files.
3177 if c, ok := ccDep.(*Module); ok {
3178 staticLib := c.linker.(libraryInterface)
3179 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3180 staticLib.objs().coverageFiles...)
3181 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3182 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003183 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003184 // Handle non-CC modules here
3185 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003186 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003187 }
3188 }
3189
Colin Cross6e511a92020-07-27 21:26:48 -07003190 if ptr != nil {
3191 if !linkFile.Valid() {
3192 if !ctx.Config().AllowMissingDependencies() {
3193 ctx.ModuleErrorf("module %q missing output file", depName)
3194 } else {
3195 ctx.AddMissingDependencies([]string{depName})
3196 }
3197 return
3198 }
3199 *ptr = append(*ptr, linkFile.Path())
3200 }
3201
3202 if depPtr != nil {
3203 dep := depFile
3204 if !dep.Valid() {
3205 dep = linkFile
3206 }
3207 *depPtr = append(*depPtr, dep.Path())
3208 }
3209
Colin Cross0de8a1e2020-09-18 14:15:30 -07003210 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3211 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3212 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3213 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003214 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3215
3216 // Only re-export RustRlibDeps for cc static libs
3217 if c.static() {
3218 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3219 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003220
3221 if libDepTag.reexportFlags {
3222 reexportExporter(depExporterInfo)
3223 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3224 // Re-exported shared library headers must be included as well since they can help us with type information
3225 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003226 c.sabi.Properties.ReexportedIncludes = append(
3227 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003228 c.sabi.Properties.ReexportedSystemIncludes = append(
3229 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003230 }
3231
Spandan Das3faa7922024-02-26 19:42:32 +00003232 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003233 switch {
3234 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003235 c.Properties.AndroidMkHeaderLibs = append(
3236 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003237 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003238 if lib := moduleLibraryInterface(dep); lib != nil {
3239 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003240 // Add the dependency to the APEX(es) providing the library so that
3241 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003242 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003243 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003244 c.Properties.ApexesProvidingSharedLibs = append(
3245 c.Properties.ApexesProvidingSharedLibs, an)
3246 }
3247 }
3248 }
3249
3250 // Note: the order of libs in this list is not important because
3251 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003252 c.Properties.AndroidMkSharedLibs = append(
3253 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003254 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003255 if !ccDep.RustLibraryInterface() {
3256 if libDepTag.wholeStatic {
3257 c.Properties.AndroidMkWholeStaticLibs = append(
3258 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3259 } else {
3260 c.Properties.AndroidMkStaticLibs = append(
3261 c.Properties.AndroidMkStaticLibs, makeLibName)
3262 }
Colin Cross6e511a92020-07-27 21:26:48 -07003263 }
3264 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003265 } else if !c.IsStubs() {
3266 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3267
Colin Cross6e511a92020-07-27 21:26:48 -07003268 switch depTag {
3269 case runtimeDepTag:
3270 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003271 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003272 case objDepTag:
3273 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3274 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003275 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003276 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003277 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003278 case dynamicLinkerDepTag:
3279 depPaths.DynamicLinker = linkFile
3280 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003281 }
Colin Crossca860ac2016-01-04 14:34:37 -08003282 })
3283
Jeff Gaston294356f2017-09-27 17:05:30 -07003284 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003285 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3286 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3287 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003288
Colin Crossdd84e052017-05-17 13:44:16 -07003289 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003290 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003291 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3292 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003293 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003294 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3295
Jiyong Park74955042019-10-22 20:19:51 +09003296 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3297 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003298 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003299 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003300 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003301 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003302
3303 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003304 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003305 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003306 }
Colin Crossdd84e052017-05-17 13:44:16 -07003307
Colin Crossca860ac2016-01-04 14:34:37 -08003308 return depPaths
3309}
3310
Spandan Das604f3762023-03-16 22:51:40 +00003311func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003312 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003313 thisModule, ok := ctx.Module().(android.ApexModule)
3314 if !ok {
3315 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3316 }
3317
Kiyoung Kimaa394802024-01-08 12:55:45 +09003318 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003319 bootstrap := false
3320 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3321 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3322 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003323 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003324 bootstrap = linkable.Bootstrap()
3325 }
3326
Colin Crossff694a82023-12-13 15:54:49 -08003327 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003328
3329 useStubs := false
3330
Kiyoung Kimaa394802024-01-08 12:55:45 +09003331 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003332 if !apexInfo.IsForPlatform() {
3333 // For platform libraries, use current version of LLNDK
3334 // If this is for use_vendor apex we will apply the same rules
3335 // of apex sdk enforcement below to choose right version.
3336 useStubs = true
3337 }
3338 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3339 // If not building for APEX or the containing APEX allows the use of
3340 // platform APIs, use stubs only when it is from an APEX (and not from
3341 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3342 // bootstrap modules, always link to non-stub variant
3343 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3344
Spandan Dasff665182024-09-11 18:48:44 +00003345 useStubs = isNotInPlatform && !bootstrap
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003346
3347 if useStubs {
3348 // Another exception: if this module is a test for an APEX, then
3349 // it is linked with the non-stub variant of a module in the APEX
3350 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003351 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003352 for _, apexContents := range testFor.ApexContents {
3353 if apexContents.DirectlyInApex(depName) {
3354 useStubs = false
3355 break
3356 }
3357 }
3358 }
3359 if useStubs {
3360 // Yet another exception: If this module and the dependency are
3361 // available to the same APEXes then skip stubs between their
3362 // platform variants. This complements the test_for case above,
3363 // which avoids the stubs on a direct APEX library dependency, by
3364 // avoiding stubs for indirect test dependencies as well.
3365 //
3366 // TODO(b/183882457): This doesn't work if the two libraries have
3367 // only partially overlapping apex_available. For that test_for
3368 // modules would need to be split into APEX variants and resolved
3369 // separately for each APEX they have access to.
Spandan Dasff665182024-09-11 18:48:44 +00003370 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003371 useStubs = false
3372 }
3373 }
3374 } else {
3375 // If building for APEX, use stubs when the parent is in any APEX that
3376 // the child is not in.
3377 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3378 }
3379
3380 return useStubs
3381}
3382
3383// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3384// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3385// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3386// has different level of updatability. For example, if a library foo in an APEX depends on a
3387// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3388// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3389// same APEX as foo, the non-stub variant of bar is used.
3390func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3391 depTag := ctx.OtherModuleDependencyTag(dep)
3392 libDepTag, ok := depTag.(libraryDependencyTag)
3393 if !ok || !libDepTag.shared() {
3394 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3395 }
3396
Colin Cross313aa542023-12-13 13:47:44 -08003397 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3398 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3399 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003400
3401 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003402 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003403 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003404 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3405 toUse := stubs[len(stubs)-1]
3406 sharedLibraryInfo = toUse.SharedLibraryInfo
3407 depExporterInfo = toUse.FlagExporterInfo
3408 }
3409 }
3410 return sharedLibraryInfo, depExporterInfo
3411}
3412
Colin Cross0de8a1e2020-09-18 14:15:30 -07003413// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3414// to match the topological order of the dependency tree, including any static analogues of
Colin Crossa14fb6a2024-10-23 16:57:06 -07003415// direct shared libraries. It returns the ordered static dependencies, and a depset.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07003416// of the transitive dependencies.
Colin Crossa14fb6a2024-10-23 16:57:06 -07003417func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive depset.DepSet[android.Path]) {
3418 transitiveStaticLibsBuilder := depset.NewBuilder[android.Path](depset.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003419 var staticPaths android.Paths
3420 for _, staticDep := range staticDeps {
3421 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3422 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3423 }
3424 for _, sharedDep := range sharedDeps {
Colin Crossa14fb6a2024-10-23 16:57:06 -07003425 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003426 }
3427 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3428
3429 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3430
3431 // reorder the dependencies based on transitive dependencies
3432 staticPaths = android.FirstUniquePaths(staticPaths)
3433 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3434
3435 if len(orderedStaticPaths) != len(staticPaths) {
3436 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3437 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3438 }
3439
3440 return orderedStaticPaths, transitiveStaticLibs
3441}
3442
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003443// BaseLibName trims known prefixes and suffixes
3444func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003445 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3446 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003447 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003448 return libName
3449}
3450
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003451func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003452 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003453 ccDepModule, _ := ccDep.(*Module)
3454 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003455 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003456
Justin Yuncbca3732021-02-03 19:24:13 +09003457 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003458 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003459 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003460 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003461
Ivan Lozanod1dec542021-05-26 15:33:11 -04003462 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003463 }
3464 }
3465
Kiyoung Kim22152f62024-05-24 10:45:28 +09003466 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003467 // The vendor and product modules in Make will have been renamed to not conflict with the
3468 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003469 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003470 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003471 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003472 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003473 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003474 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003475 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003476 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003477 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003478 } else {
3479 return libName
3480 }
3481}
3482
Colin Crossca860ac2016-01-04 14:34:37 -08003483func (c *Module) InstallInData() bool {
3484 if c.installer == nil {
3485 return false
3486 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003487 return c.installer.inData()
3488}
3489
3490func (c *Module) InstallInSanitizerDir() bool {
3491 if c.installer == nil {
3492 return false
3493 }
3494 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003495 return true
3496 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003497 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003498}
3499
Yifan Hong1b3348d2020-01-21 15:53:22 -08003500func (c *Module) InstallInRamdisk() bool {
3501 return c.InRamdisk()
3502}
3503
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003504func (c *Module) InstallInVendorRamdisk() bool {
3505 return c.InVendorRamdisk()
3506}
3507
Jiyong Parkf9332f12018-02-01 00:54:12 +09003508func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003509 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003510}
3511
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003512func (c *Module) MakeUninstallable() {
3513 if c.installer == nil {
3514 c.ModuleBase.MakeUninstallable()
3515 return
3516 }
3517 c.installer.makeUninstallable(c)
3518}
3519
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003520func (c *Module) HostToolPath() android.OptionalPath {
3521 if c.installer == nil {
3522 return android.OptionalPath{}
3523 }
3524 return c.installer.hostToolPath()
3525}
3526
Nan Zhangd4e641b2017-07-12 12:55:28 -07003527func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3528 return c.outputFile
3529}
3530
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003531func (c *Module) static() bool {
3532 if static, ok := c.linker.(interface {
3533 static() bool
3534 }); ok {
3535 return static.static()
3536 }
3537 return false
3538}
3539
Jiyong Park379de2f2018-12-19 02:47:14 +09003540func (c *Module) staticBinary() bool {
3541 if static, ok := c.linker.(interface {
3542 staticBinary() bool
3543 }); ok {
3544 return static.staticBinary()
3545 }
3546 return false
3547}
3548
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003549func (c *Module) testBinary() bool {
3550 if test, ok := c.linker.(interface {
3551 testBinary() bool
3552 }); ok {
3553 return test.testBinary()
3554 }
3555 return false
3556}
3557
Jingwen Chen537242c2022-08-24 11:53:27 +00003558func (c *Module) testLibrary() bool {
3559 if test, ok := c.linker.(interface {
3560 testLibrary() bool
3561 }); ok {
3562 return test.testLibrary()
3563 }
3564 return false
3565}
3566
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003567func (c *Module) benchmarkBinary() bool {
3568 if b, ok := c.linker.(interface {
3569 benchmarkBinary() bool
3570 }); ok {
3571 return b.benchmarkBinary()
3572 }
3573 return false
3574}
3575
3576func (c *Module) fuzzBinary() bool {
3577 if f, ok := c.linker.(interface {
3578 fuzzBinary() bool
3579 }); ok {
3580 return f.fuzzBinary()
3581 }
3582 return false
3583}
3584
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003585// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3586func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003587 if h, ok := c.linker.(interface {
3588 header() bool
3589 }); ok {
3590 return h.header()
3591 }
3592 return false
3593}
3594
Ivan Lozanod7586b62021-04-01 09:49:36 -04003595func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003596 if b, ok := c.linker.(interface {
3597 binary() bool
3598 }); ok {
3599 return b.binary()
3600 }
3601 return false
3602}
3603
Justin Yun5e035862021-06-29 20:50:37 +09003604func (c *Module) StaticExecutable() bool {
3605 if b, ok := c.linker.(*binaryDecorator); ok {
3606 return b.static()
3607 }
3608 return false
3609}
3610
Ivan Lozanod7586b62021-04-01 09:49:36 -04003611func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003612 if o, ok := c.linker.(interface {
3613 object() bool
3614 }); ok {
3615 return o.object()
3616 }
3617 return false
3618}
3619
Kiyoung Kim37693d02024-04-04 09:56:15 +09003620func (m *Module) Dylib() bool {
3621 return false
3622}
3623
3624func (m *Module) Rlib() bool {
3625 return false
3626}
3627
Ivan Lozanof9e21722020-12-02 09:00:51 -05003628func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003629 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003630 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003631 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003632 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003633 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003634 return "native:product"
3635 }
Jooyung Han38002912019-05-16 04:01:54 +09003636 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003637 } else if c.InRamdisk() {
3638 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003639 } else if c.InVendorRamdisk() {
3640 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003641 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003642 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003643 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003644 return "native:ndk:none:none"
3645 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3646 //family, link := getNdkStlFamilyAndLinkType(c)
3647 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3648 } else {
3649 return "native:platform"
3650 }
3651}
3652
Jiyong Park9d452992018-10-03 00:38:19 +09003653// Overrides ApexModule.IsInstallabeToApex()
Colin Cross3a02c7b2024-05-21 13:46:22 -07003654// Only shared/runtime libraries .
Jiyong Park9d452992018-10-03 00:38:19 +09003655func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003656 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003657 // Stub libs and prebuilt libs in a versioned SDK are not
3658 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003659 return lib.shared() && !lib.buildStubs()
Jiyong Park9d452992018-10-03 00:38:19 +09003660 }
3661 return false
3662}
3663
Jiyong Parka90ca002019-10-07 15:47:24 +09003664func (c *Module) AvailableFor(what string) bool {
3665 if linker, ok := c.linker.(interface {
3666 availableFor(string) bool
3667 }); ok {
3668 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3669 } else {
3670 return c.ApexModuleBase.AvailableFor(what)
3671 }
3672}
3673
Jiyong Park62304bb2020-04-13 16:19:48 +09003674func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003675 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003676}
3677
Paul Duffin0cb37b92020-03-04 14:52:46 +00003678func (c *Module) EverInstallable() bool {
3679 return c.installer != nil &&
3680 // Check to see whether the module is actually ever installable.
3681 c.installer.everInstallable()
3682}
3683
Ivan Lozanod7586b62021-04-01 09:49:36 -04003684func (c *Module) PreventInstall() bool {
3685 return c.Properties.PreventInstall
3686}
3687
3688func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003689 if c.library != nil {
3690 if i := c.library.installable(); i != nil {
3691 return i
3692 }
3693 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003694 return c.Properties.Installable
3695}
3696
3697func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003698 ret := c.EverInstallable() &&
3699 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003700 proptools.BoolDefault(c.Installable(), true) &&
3701 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003702
3703 // The platform variant doesn't need further condition. Apex variants however might not
3704 // be installable because it will likely to be included in the APEX and won't appear
3705 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003706 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003707 return ret
3708 }
3709
3710 // Special case for modules that are configured to be installed to /data, which includes
3711 // test modules. For these modules, both APEX and non-APEX variants are considered as
3712 // installable. This is because even the APEX variants won't be included in the APEX, but
3713 // will anyway be installed to /data/*.
3714 // See b/146995717
3715 if c.InstallInData() {
3716 return ret
3717 }
3718
3719 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003720}
3721
Logan Chien41eabe62019-04-10 13:33:58 +08003722func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3723 if c.linker != nil {
3724 if library, ok := c.linker.(*libraryDecorator); ok {
3725 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3726 }
3727 }
3728}
3729
Jiyong Park45bf82e2020-12-15 22:29:02 +09003730var _ android.ApexModule = (*Module)(nil)
3731
3732// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003733func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003734 depTag := ctx.OtherModuleDependencyTag(dep)
3735 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3736
3737 if cc, ok := dep.(*Module); ok {
3738 if cc.HasStubsVariants() {
3739 if isLibDepTag && libDepTag.shared() {
3740 // dynamic dep to a stubs lib crosses APEX boundary
3741 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003742 }
Colin Cross6e511a92020-07-27 21:26:48 -07003743 if IsRuntimeDepTag(depTag) {
3744 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003745 return false
3746 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003747 }
Zhijun Heec285872021-04-24 10:47:08 -07003748 if cc.IsLlndk() {
3749 return false
3750 }
Colin Crossaac32222020-07-29 12:51:56 -07003751 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003752 // shared_lib dependency from a static lib is considered as crossing
3753 // the APEX boundary because the dependency doesn't actually is
3754 // linked; the dependency is used only during the compilation phase.
3755 return false
3756 }
Jiyong Parke3867542020-12-03 17:28:25 +09003757
3758 if isLibDepTag && libDepTag.excludeInApex {
3759 return false
3760 }
Colin Cross6e511a92020-07-27 21:26:48 -07003761 }
Colin Crossc1b36442021-05-06 13:42:48 -07003762 if depTag == stubImplDepTag {
3763 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003764 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003765 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003766 if depTag == staticVariantTag {
3767 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3768 // actually mean that the static lib (and its dependencies) are copied into the
3769 // APEX.
3770 return false
3771 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003772 return true
3773}
3774
Jiyong Park45bf82e2020-12-15 22:29:02 +09003775// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003776func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3777 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003778 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3779 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3780 return nil
3781 }
Jooyung Han749dc692020-04-15 11:03:39 +09003782 // We don't check for prebuilt modules
3783 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3784 return nil
3785 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003786
Jooyung Han749dc692020-04-15 11:03:39 +09003787 minSdkVersion := c.MinSdkVersion()
3788 if minSdkVersion == "apex_inherit" {
3789 return nil
3790 }
3791 if minSdkVersion == "" {
3792 // JNI libs within APK-in-APEX fall into here
3793 // Those are okay to set sdk_version instead
3794 // We don't have to check if this is a SDK variant because
3795 // non-SDK variant resets sdk_version, which works too.
3796 minSdkVersion = c.SdkVersion()
3797 }
Dan Albertc8060532020-07-22 22:32:17 -07003798 if minSdkVersion == "" {
3799 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3800 }
3801 // Not using nativeApiLevelFromUser because the context here is not
3802 // necessarily a native context.
3803 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003804 if err != nil {
3805 return err
3806 }
Dan Albertc8060532020-07-22 22:32:17 -07003807
Colin Cross8ca61c12022-10-06 21:00:14 -07003808 // A dependency only needs to support a min_sdk_version at least
3809 // as high as the api level that the architecture was introduced in.
3810 // This allows introducing new architectures in the platform that
3811 // need to be included in apexes that normally require an older
3812 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003813 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003814 if sdkVersion.LessThan(minApiForArch) {
3815 sdkVersion = minApiForArch
3816 }
3817
Dan Albertc8060532020-07-22 22:32:17 -07003818 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003819 return fmt.Errorf("newer SDK(%v)", ver)
3820 }
3821 return nil
3822}
3823
Paul Duffinb5769c12021-05-12 16:16:51 +01003824// Implements android.ApexModule
3825func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3826 // stub libraries and native bridge libraries are always available to platform
3827 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3828}
3829
Inseob Kima1888ce2022-10-04 14:42:02 +09003830func (c *Module) overriddenModules() []string {
3831 if o, ok := c.linker.(overridable); ok {
3832 return o.overriddenModules()
3833 }
3834 return nil
3835}
3836
Liz Kammer35ca77e2021-12-22 15:31:40 -05003837type moduleType int
3838
3839const (
3840 unknownType moduleType = iota
3841 binary
3842 object
3843 fullLibrary
3844 staticLibrary
3845 sharedLibrary
3846 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003847 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003848 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003849)
3850
3851func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003852 if c.testBinary() {
3853 // testBinary is also a binary, so this comes before the c.Binary()
3854 // conditional. A testBinary has additional implicit dependencies and
3855 // other test-only semantics.
3856 return testBin
3857 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003858 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003859 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003860 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003861 } else if c.testLibrary() {
3862 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3863 // will let them add implicit compile deps on gtest, for example.
3864 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003865 // For now, treat them as regular libraries.
3866 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003867 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003868 static := false
3869 shared := false
3870 if library, ok := c.linker.(*libraryDecorator); ok {
3871 static = library.MutatedProperties.BuildStatic
3872 shared = library.MutatedProperties.BuildShared
3873 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3874 static = library.MutatedProperties.BuildStatic
3875 shared = library.MutatedProperties.BuildShared
3876 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003877 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003878 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003879 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003880 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003881 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003882 return staticLibrary
3883 }
3884 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003885 } else if c.isNDKStubLibrary() {
3886 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003887 }
3888 return unknownType
3889}
3890
Colin Crosscfad1192015-11-02 16:43:11 -08003891// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003892type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003893 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003894 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003895 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003896}
3897
Patrice Arrudac249c712019-03-19 17:00:29 -07003898// cc_defaults provides a set of properties that can be inherited by other cc
3899// modules. A module can use the properties from a cc_defaults using
3900// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3901// merged (when possible) by prepending the default module's values to the
3902// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003903func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003904 return DefaultsFactory()
3905}
3906
Colin Cross36242852017-06-23 15:06:31 -07003907func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003908 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003909
Colin Cross36242852017-06-23 15:06:31 -07003910 module.AddProperties(props...)
3911 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003912 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003913 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003914 &BaseCompilerProperties{},
3915 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003916 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003917 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003918 &StaticProperties{},
3919 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003920 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003921 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003922 &TestLinkerProperties{},
3923 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003924 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003925 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003926 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003927 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003928 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003929 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003930 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003931 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003932 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003933 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003934 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003935 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00003936 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003937 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003938 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3939 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003940 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003941 )
Colin Crosscfad1192015-11-02 16:43:11 -08003942
Jooyung Hancc372c52019-09-25 15:18:44 +09003943 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003944
3945 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003946}
3947
Jiyong Park2286afd2020-06-16 21:58:53 +09003948func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003949 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003950}
3951
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003952func kytheExtractAllFactory() android.Singleton {
3953 return &kytheExtractAllSingleton{}
3954}
3955
3956type kytheExtractAllSingleton struct {
3957}
3958
3959func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3960 var xrefTargets android.Paths
3961 ctx.VisitAllModules(func(module android.Module) {
3962 if ccModule, ok := module.(xref); ok {
3963 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3964 }
3965 })
3966 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3967 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003968 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003969 }
3970}
3971
Jihoon Kangf78a8902022-09-01 22:47:07 +00003972func (c *Module) Partition() string {
3973 if p, ok := c.installer.(interface {
3974 getPartition() string
3975 }); ok {
3976 return p.getPartition()
3977 }
3978 return ""
3979}
3980
Spandan Das2b6dfb52024-01-19 00:22:22 +00003981type sourceModuleName interface {
3982 sourceModuleName() string
3983}
3984
3985func (c *Module) BaseModuleName() string {
3986 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
3987 // if the prebuilt module sets a source_module_name in Android.bp, use that
3988 return smn.sourceModuleName()
3989 }
3990 return c.ModuleBase.BaseModuleName()
3991}
3992
Spandan Dase20c56c2024-07-23 21:34:24 +00003993func (c *Module) stubsSymbolFilePath() android.Path {
3994 if library, ok := c.linker.(*libraryDecorator); ok {
3995 return library.stubsSymbolFilePath
3996 }
3997 return android.OptionalPath{}.Path()
3998}
3999
Colin Cross06a931b2015-10-28 17:23:31 -07004000var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004001var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004002var BoolPtr = proptools.BoolPtr
4003var String = proptools.String
4004var StringPtr = proptools.StringPtr