blob: 6641182f97c6907117080e48e638e63b961c2842 [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 Cross516c5452024-10-28 13:45:21 -070022 "errors"
Colin Cross41955e82019-05-29 14:40:35 -070023 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080024 "io"
Colin Cross516c5452024-10-28 13:45:21 -070025 "slices"
Dan Albert9e10cd42016-08-03 14:12:14 -070026 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080027 "strings"
28
Colin Cross97ba0732015-03-23 17:50:24 -070029 "github.com/google/blueprint"
Colin Crossa14fb6a2024-10-23 16:57:06 -070030 "github.com/google/blueprint/depset"
Colin Cross06a931b2015-10-28 17:23:31 -070031 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070032
Vinh Tran367d89d2023-04-28 11:21:25 -040033 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070034 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070035 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070036 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070037 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080038)
39
Yu Liu76d94462024-10-31 23:32:36 +000040type CcMakeVarsInfo struct {
41 WarningsAllowed string
42 UsingWnoError string
43 MissingProfile string
44}
45
46var CcMakeVarsInfoProvider = blueprint.NewProvider[*CcMakeVarsInfo]()
47
Yu Liuec7043d2024-11-05 18:22:20 +000048type CcObjectInfo struct {
49 objFiles android.Paths
50 tidyFiles android.Paths
51 kytheFiles android.Paths
52}
53
54var CcObjectInfoProvider = blueprint.NewProvider[CcObjectInfo]()
55
Yu Liub1bfa9d2024-12-05 18:57:51 +000056// Common info about the cc module.
57type CcInfo struct {
58 HasStubsVariants bool
59}
60
61var CcInfoProvider = blueprint.NewProvider[CcInfo]()
62
Yu Liu986d98c2024-11-12 00:28:11 +000063type LinkableInfo struct {
64 // StaticExecutable returns true if this is a binary module with "static_executable: true".
65 StaticExecutable bool
66}
67
68var LinkableInfoKey = blueprint.NewProvider[LinkableInfo]()
69
Colin Cross463a90e2015-06-17 14:20:06 -070070func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000071 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070072
Inseob Kim3b244062023-07-11 13:31:36 +090073 pctx.Import("android/soong/android")
Paul Duffin036e7002019-12-19 19:16:28 +000074 pctx.Import("android/soong/cc/config")
75}
76
77func RegisterCCBuildComponents(ctx android.RegistrationContext) {
78 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
79
80 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossac57a6c2024-06-26 13:09:53 -070081 ctx.Transition("sdk", &sdkTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070082 ctx.BottomUp("llndk", llndkMutator)
Colin Cross767819f2024-05-22 14:22:34 -070083 ctx.Transition("link", &linkageTransitionMutator{})
Colin Crossadd04a82024-05-22 09:57:59 -070084 ctx.Transition("version", &versionTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070085 ctx.BottomUp("begin", BeginMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070086 })
Colin Cross16b23492016-01-06 14:41:07 -080087
Paul Duffin036e7002019-12-19 19:16:28 +000088 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040089 for _, san := range Sanitizers {
90 san.registerMutators(ctx)
91 }
Dan Willemsen581341d2017-02-09 16:16:31 -080092
Colin Cross8a962802024-10-09 15:29:27 -070093 ctx.BottomUp("sanitize_runtime_deps", sanitizerRuntimeDepsMutator)
94 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator)
Ivan Lozano30c5db22018-02-21 15:49:20 -080095
Colin Cross597bad62024-10-08 15:10:55 -070096 ctx.Transition("fuzz", &fuzzTransitionMutator{})
Cory Barkera1da26f2022-06-07 20:12:06 +000097
Colin Crossf5f4ad32024-01-19 15:41:48 -080098 ctx.Transition("coverage", &coverageTransitionMutator{})
Stephen Craneba090d12017-05-09 15:44:35 -070099
Colin Crossd38feb02024-01-23 16:38:06 -0800100 ctx.Transition("afdo", &afdoTransitionMutator{})
Yi Kongeb8efc92021-12-09 18:06:29 +0800101
Colin Cross33e0c812024-01-23 16:36:07 -0800102 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000103
Colin Cross6ac83a82024-01-23 11:23:10 -0800104 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +0900105
Colin Cross8a962802024-10-09 15:29:27 -0700106 ctx.BottomUp("check_linktype", checkLinkTypeMutator)
107 ctx.BottomUp("double_loadable", checkDoubleLoadableLibraries)
Colin Cross1e676be2016-10-12 14:38:15 -0700108 })
Colin Crossb98c8b02016-07-29 13:44:28 -0700109
Colin Cross91ae5ec2024-10-01 14:03:40 -0700110 ctx.PostApexMutators(func(ctx android.RegisterMutatorsContext) {
Yo Chiang8aa4e3f2020-11-19 16:30:49 +0800111 // sabi mutator needs to be run after apex mutator finishes.
Colin Cross91ae5ec2024-10-01 14:03:40 -0700112 ctx.Transition("sabi", &sabiTransitionMutator{})
Yo Chiang8aa4e3f2020-11-19 16:30:49 +0800113 })
114
LaMont Jones0c10e4d2023-05-16 00:58:37 +0000115 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -0700116}
117
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500118// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
119// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
120// edges to these modules.
121// This object is constructed in DepsMutator, by calling to various module delegates to set
122// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
123// dependencies.
124// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
125// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -0800126type Deps struct {
127 SharedLibs, LateSharedLibs []string
128 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800129 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800130 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700131
Colin Cross3e5e7782022-06-17 22:17:05 +0000132 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
133 // prevent automatically exporting symbols.
134 UnexportedStaticLibs []string
135
Chris Parsons79d66a52020-06-05 17:26:16 -0400136 // Used for data dependencies adjacent to tests
137 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700138 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400139
Yo Chiang219968c2020-09-22 18:45:04 +0800140 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
141 SystemSharedLibs []string
142
Vinh Tran367d89d2023-04-28 11:21:25 -0400143 // Used by DepMutator to pass aidl_library modules to aidl compiler
144 AidlLibs []string
145
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500146 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800147 StaticUnwinderIfLegacy bool
148
Colin Cross5950f382016-12-13 12:50:57 -0800149 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700150
Colin Cross81413472016-04-11 14:37:39 -0700151 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700152
Cole Faust65cb40a2024-10-21 15:41:42 -0700153 GeneratedSources []string
154 GeneratedHeaders []string
155 DeviceFirstGeneratedHeaders []string
156 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700157
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700158 ReexportGeneratedHeaders []string
159
Colin Crossc465efd2021-06-11 18:00:04 -0700160 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700161
162 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700163 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900164
165 // List of libs that need to be excluded for APEX variant
166 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900167 // List of libs that need to be excluded for non-APEX variant
168 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800169
170 // LLNDK headers for the ABI checker to check LLNDK implementation library.
171 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
Colin Cross1e954b62024-09-13 13:50:00 -0700172 // The core variant cannot depend on the vendor variant because of the order of imageTransitionMutator.Split().
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800173 // Instead, the LLNDK implementation depends on the LLNDK header libs.
174 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700175}
176
Ivan Lozano0a468a42024-05-13 21:03:34 -0400177// A struct which to collect flags for rlib dependencies
178type RustRlibDep struct {
179 LibPath android.Path // path to the rlib
180 LinkDirs []string // flags required for dependency (e.g. -L flags)
181 CrateName string // crateNames associated with rlibDeps
182}
183
184func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
185 return a.LibPath == b.LibPath
186}
187
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500188// PathDeps is a struct containing file paths to dependencies of a module.
189// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
190// It's used to construct flags for various build statements (such as for compiling and linking).
191// It is then passed to module decorator functions responsible for registering build statements
192// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800193type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700194 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900195 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700196 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900197 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700198 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700199 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400200 // Paths and crateNames for RustStaticLib dependencies
201 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700202
Colin Cross0de8a1e2020-09-18 14:15:30 -0700203 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossa14fb6a2024-10-23 16:57:06 -0700204 TranstiveStaticLibrariesForOrdering depset.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700205
Colin Cross26c34ed2016-09-30 17:10:16 -0700206 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100207 Objs Objects
208 // Paths to .o files in dependencies that provide them. Note that these lists
209 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800210 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700211 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700212
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100213 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
214 // the libs from all whole_static_lib dependencies.
215 WholeStaticLibsFromPrebuilts android.Paths
216
Colin Cross26c34ed2016-09-30 17:10:16 -0700217 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700218 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900219 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700220
Inseob Kimd110f872019-12-06 13:15:38 +0900221 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000222 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900223 IncludeDirs android.Paths
224 SystemIncludeDirs android.Paths
225 ReexportedDirs android.Paths
226 ReexportedSystemDirs android.Paths
227 ReexportedFlags []string
228 ReexportedGeneratedHeaders android.Paths
229 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400230 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700231
Colin Cross26c34ed2016-09-30 17:10:16 -0700232 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700233 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700234
Dan Willemsena0790e32018-10-12 00:24:23 -0700235 // Path to the dynamic linker binary
236 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700237
238 // For Darwin builds, the path to the second architecture's output that should
239 // be combined with this architectures's output into a FAT MachO file.
240 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400241
242 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
243 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800244
245 // LLNDK headers for the ABI checker to check LLNDK implementation library.
246 LlndkIncludeDirs android.Paths
247 LlndkSystemIncludeDirs android.Paths
Colin Crossb614cd42024-10-11 12:52:21 -0700248
249 directImplementationDeps android.Paths
250 transitiveImplementationDeps []depset.DepSet[android.Path]
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700251}
252
Colin Cross4af21ed2019-11-04 09:37:55 -0800253// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
254// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
255// command line so they can be overridden by the local module flags).
256type LocalOrGlobalFlags struct {
257 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700258 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800259 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700260 CFlags []string // Flags that apply to C and C++ source files
261 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
262 ConlyFlags []string // Flags that apply to C source files
263 CppFlags []string // Flags that apply to C++ source files
264 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700265 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800266}
267
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500268// Flags contains various types of command line flags (and settings) for use in building build
269// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800270type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500271 // Local flags (which individual modules are responsible for). These may override global flags.
272 Local LocalOrGlobalFlags
273 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700274 Global LocalOrGlobalFlags
275 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800276
277 aidlFlags []string // Flags that apply to aidl source files
278 rsFlags []string // Flags that apply to renderscript source files
279 libFlags []string // Flags to add libraries early to the link order
280 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
281 TidyFlags []string // Flags that apply to clang-tidy
282 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700283
Colin Crossc3199482017-03-30 15:03:04 -0700284 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800285 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700286 SystemIncludeFlags []string
287
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800288 Toolchain config.Toolchain
289 Tidy bool // True if ninja .tidy rules should be generated.
290 NeedTidyFiles bool // True if module link should depend on .tidy files
291 GcovCoverage bool // True if coverage files should be generated.
292 SAbiDump bool // True if header abi dumps should be generated.
293 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800294 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800295
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500296 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800297 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500298 // The target-device system path to the dynamic linker.
299 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800300
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700301 CFlagsDeps android.Paths // Files depended on by compiler flags
302 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800303
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500304 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700305 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800306
Colin Cross19878da2019-03-28 14:45:07 -0700307 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700308 protoC bool // Whether to use C instead of C++
309 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700310
311 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200312 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700313}
314
Colin Crossca860ac2016-01-04 14:34:37 -0800315// Properties used to compile all C or C++ modules
316type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700317 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800318 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700319
Yi Kong5786f5c2024-05-28 02:22:34 +0900320 // Aggresively trade performance for smaller binary size.
321 // This should only be used for on-device binaries that are rarely executed and not
322 // performance critical.
323 Optimize_for_size *bool `android:"arch_variant"`
324
Jiyong Parkb35a8192020-08-10 15:59:36 +0900325 // The API level that this module is built against. The APIs of this API level will be
326 // visible at build time, but use of any APIs newer than min_sdk_version will render the
327 // module unloadable on older devices. In the future it will be possible to weakly-link new
328 // APIs, making the behavior match Java: such modules will load on older devices, but
329 // calling new APIs on devices that do not support them will result in a crash.
330 //
331 // This property has the same behavior as sdk_version does for Java modules. For those
332 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
333 // does for Java code.
334 //
335 // In addition, setting this property causes two variants to be built, one for the platform
336 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800337 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700338
Jiyong Parkb35a8192020-08-10 15:59:36 +0900339 // Minimum OS API level supported by this C or C++ module. This property becomes the value
340 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
341 // this property is also used to ensure that the min_sdk_version of the containing module is
342 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
343 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
344 // min_sdk_version of the containing APEX. When the module
345 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900346 Min_sdk_version *string
347
Colin Crossc511bc52020-04-07 16:50:32 +0000348 // If true, always create an sdk variant and don't create a platform variant.
349 Sdk_variant_only *bool
350
Colin Cross4297f402024-11-20 15:20:09 -0800351 AndroidMkSharedLibs []string `blueprint:"mutated"`
352 AndroidMkStaticLibs []string `blueprint:"mutated"`
353 AndroidMkRlibs []string `blueprint:"mutated"`
354 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
355 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
356 AndroidMkHeaderLibs []string `blueprint:"mutated"`
357 HideFromMake bool `blueprint:"mutated"`
358 PreventInstall bool `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700359
Yo Chiang219968c2020-09-22 18:45:04 +0800360 // Set by DepsMutator.
361 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
362
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900363 // The name of the image this module is built for
364 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200365
366 // The VNDK version this module is built against. If empty, the module is not
367 // build against the VNDK.
368 VndkVersion string `blueprint:"mutated"`
369
370 // Suffix for the name of Android.mk entries generated by this module
371 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800372
373 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
374 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900375 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900376
Yifan Hong39143a92020-10-26 12:43:12 -0700377 // Make this module available when building for ramdisk.
378 // On device without a dedicated recovery partition, the module is only
379 // available after switching root into
380 // /first_stage_ramdisk. To expose the module before switching root, install
381 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800382 Ramdisk_available *bool
383
Yifan Hong39143a92020-10-26 12:43:12 -0700384 // Make this module available when building for vendor ramdisk.
385 // On device without a dedicated recovery partition, the module is only
386 // available after switching root into
387 // /first_stage_ramdisk. To expose the module before switching root, install
388 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700389 Vendor_ramdisk_available *bool
390
Jiyong Parkf9332f12018-02-01 00:54:12 +0900391 // Make this module available when building for recovery
392 Recovery_available *bool
393
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200394 // Used by imageMutator, set by ImageMutatorBegin()
Jihoon Kang47e91842024-06-19 00:51:16 +0000395 VendorVariantNeeded bool `blueprint:"mutated"`
396 ProductVariantNeeded bool `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200397 CoreVariantNeeded bool `blueprint:"mutated"`
398 RamdiskVariantNeeded bool `blueprint:"mutated"`
399 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
400 RecoveryVariantNeeded bool `blueprint:"mutated"`
401
402 // A list of variations for the "image" mutator of the form
403 //<image name> '.' <version char>, for example, 'vendor.S'
404 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900405
406 // Allows this module to use non-APEX version of libraries. Useful
407 // for building binaries that are started before APEXes are activated.
408 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900409
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000410 // Allows this module to be included in CMake release snapshots to be built outside of Android
411 // build system and source tree.
412 Cmake_snapshot_supported *bool
413
Colin Cross1bc94122021-10-28 13:25:54 -0700414 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000415
416 // Set by factories of module types that can only be referenced from variants compiled against
417 // the SDK.
418 AlwaysSdk bool `blueprint:"mutated"`
419
420 // Variant is an SDK variant created by sdkMutator
421 IsSdkVariant bool `blueprint:"mutated"`
422 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
423 // variant to have a ".sdk" suffix.
424 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700425
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800426 Target struct {
427 Platform struct {
428 // List of modules required by the core variant.
429 Required []string `android:"arch_variant"`
430
431 // List of modules not required by the core variant.
432 Exclude_required []string `android:"arch_variant"`
433 } `android:"arch_variant"`
434
435 Recovery struct {
436 // List of modules required by the recovery variant.
437 Required []string `android:"arch_variant"`
438
439 // List of modules not required by the recovery variant.
440 Exclude_required []string `android:"arch_variant"`
441 } `android:"arch_variant"`
442 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700443}
444
445type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900446 // whether this module should be allowed to be directly depended by other
447 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900448 // If set to true, two variants will be built separately, one like
449 // normal, and the other limited to the set of libraries and headers
450 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700451 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900452 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700453 // so it shouldn't have any unversioned runtime dependencies, or
454 // make assumptions about the system that may not be true in the
455 // future.
456 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900457 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900458 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900459 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900460 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900461 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700462 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
463 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900464
Justin Yunebcf0c52021-01-08 18:00:19 +0900465 // This is the same as the "vendor_available" except that the install path
466 // of the vendor variant is /odm or /vendor/odm.
467 // By replacing "vendor_available: true" with "odm_available: true", the
468 // module will install its vendor variant to the /odm partition or /vendor/odm.
469 // As the modules with "odm_available: true" still create the vendor variants,
470 // they can link to the other vendor modules as the vendor_available modules do.
471 // Also, the vendor modules can link to odm_available modules.
472 //
473 // It may not be used for VNDK modules.
474 Odm_available *bool
475
Justin Yun63e9ec72020-10-29 16:49:43 +0900476 // whether this module should be allowed to be directly depended by other
477 // modules with `product_specific: true` or `product_available: true`.
478 // If set to true, an additional product variant will be built separately
479 // that is limited to the set of libraries and headers that are exposed to
480 // /product modules.
481 //
482 // The product variant may be used with a different (newer) /system,
483 // so it shouldn't have any unversioned runtime dependencies, or
484 // make assumptions about the system that may not be true in the
485 // future.
486 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900487 // If set to false, this module becomes inaccessible from /product modules.
488 //
489 // Different from the 'vendor_available' property, the modules with
490 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
491 // library without 'product_available' may not be depended on by any other
492 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900493 //
494 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
495 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
496 Product_available *bool
497
Jiyong Park5fb8c102018-04-09 12:03:06 +0900498 // whether this module is capable of being loaded with other instance
499 // (possibly an older version) of the same module in the same process.
500 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
501 // can be double loaded in a vendor process if the library is also a
502 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
503 // explicitly marked as `double_loadable: true` by the owner, or the dependency
504 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
505 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800506
507 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
508 IsLLNDK bool `blueprint:"mutated"`
509
Colin Cross5271fea2021-04-27 13:06:04 -0700510 // IsVendorPublicLibrary is set for the core and product variants of a library that has
511 // vendor_public_library stubs.
512 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800513}
514
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500515// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
516// to understanding details about the type of the current module.
517// For example, one might call these functions to determine whether the current module is a static
518// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800519type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800520 static() bool
521 staticBinary() bool
Colin Cross6a730042024-12-05 13:53:43 -0800522 staticLibrary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700523 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800524 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900525 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900526 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900527 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700528 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900529 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700530 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800531 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900532 minSdkVersion() string
533 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700534 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700535 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800536 IsLlndk() bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800537 isImplementationForLLNDKPublic() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700538 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900539 inProduct() bool
540 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800541 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700542 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900543 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900544 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700545 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700546 baseModuleName() string
Colin Cross3513fb12024-01-24 14:44:47 -0800547 isAfdoCompile(ctx ModuleContext) bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000548 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800549 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900550 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800551 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800552 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800553 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700554 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700555 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900556 bootstrap() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700557 nativeCoverage() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800558 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800559 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800560 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800561 notInPlatform() bool
Yi Kong5786f5c2024-05-28 02:22:34 +0900562 optimizeForSize() bool
Yu Liu76d94462024-10-31 23:32:36 +0000563 getOrCreateMakeVarsInfo() *CcMakeVarsInfo
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800564}
565
566type SharedFlags struct {
567 numSharedFlags int
568 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800569}
570
571type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700572 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800573 ModuleContextIntf
574}
575
576type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700577 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800578 ModuleContextIntf
579}
580
Colin Cross37047f12016-12-13 17:06:13 -0800581type DepsContext interface {
582 android.BottomUpMutatorContext
583 ModuleContextIntf
584}
585
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500586// feature represents additional (optional) steps to building cc-related modules, such as invocation
587// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800588type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800589 flags(ctx ModuleContext, flags Flags) Flags
590 props() []interface{}
591}
592
Joe Onorato37f900c2023-07-18 16:58:16 -0700593// Information returned from Generator about the source code it's generating
594type GeneratedSource struct {
595 IncludeDirs android.Paths
596 Sources android.Paths
597 Headers android.Paths
598 ReexportedDirs android.Paths
599}
600
601// generator allows injection of generated code
602type Generator interface {
603 GeneratorProps() []interface{}
604 GeneratorInit(ctx BaseModuleContext)
605 GeneratorDeps(ctx DepsContext, deps Deps) Deps
606 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
607 GeneratorSources(ctx ModuleContext) GeneratedSource
608 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
609}
610
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500611// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500612// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800613type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700614 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800615 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800616 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700617 compilerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000618 baseCompilerProps() BaseCompilerProperties
Colin Cross42742b82016-08-01 13:20:05 -0700619
Colin Cross76fada02016-07-27 10:31:13 -0700620 appendCflags([]string)
621 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700622 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800623}
624
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500625// linker is the interface for a linker decorator object. Individual module types can provide
626// their own implementation for this decorator, and thus specify custom logic regarding build
627// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800628type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700629 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800630 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700631 linkerFlags(ctx ModuleContext, flags Flags) Flags
632 linkerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000633 baseLinkerProps() BaseLinkerProperties
Ivan Lozanobd721262018-11-27 14:33:03 -0800634 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700635
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700636 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700637 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900638 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800639 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700640
641 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900642 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000643
644 // Get the deps that have been explicitly specified in the properties.
Cole Fauste8a87832024-09-11 11:35:46 -0700645 linkerSpecifiedDeps(ctx android.ConfigurableEvaluatorContext, module *Module, specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800646
647 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000648}
649
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500650// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000651type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500652 sharedLibs []string
653 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
654 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700655 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800656}
657
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500658// installer is the interface for an installer helper object. This helper is responsible for
659// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800660type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700661 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700662 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000663 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800664 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700665 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700666 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900667 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000668 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900669 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800670}
671
Inseob Kima1888ce2022-10-04 14:42:02 +0900672type overridable interface {
673 overriddenModules() []string
674}
675
Colin Cross6e511a92020-07-27 21:26:48 -0700676type libraryDependencyKind int
677
678const (
679 headerLibraryDependency = iota
680 sharedLibraryDependency
681 staticLibraryDependency
Ivan Lozano0a468a42024-05-13 21:03:34 -0400682 rlibLibraryDependency
Colin Cross6e511a92020-07-27 21:26:48 -0700683)
684
685func (k libraryDependencyKind) String() string {
686 switch k {
687 case headerLibraryDependency:
688 return "headerLibraryDependency"
689 case sharedLibraryDependency:
690 return "sharedLibraryDependency"
691 case staticLibraryDependency:
692 return "staticLibraryDependency"
Ivan Lozano0a468a42024-05-13 21:03:34 -0400693 case rlibLibraryDependency:
694 return "rlibLibraryDependency"
Colin Cross6e511a92020-07-27 21:26:48 -0700695 default:
696 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
697 }
698}
699
700type libraryDependencyOrder int
701
702const (
703 earlyLibraryDependency = -1
704 normalLibraryDependency = 0
705 lateLibraryDependency = 1
706)
707
708func (o libraryDependencyOrder) String() string {
709 switch o {
710 case earlyLibraryDependency:
711 return "earlyLibraryDependency"
712 case normalLibraryDependency:
713 return "normalLibraryDependency"
714 case lateLibraryDependency:
715 return "lateLibraryDependency"
716 default:
717 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
718 }
719}
720
721// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
722// tags that have a set of predefined tag objects that are reused for each dependency, a
723// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
724// That means that comparing a libraryDependencyTag for equality will only be equal if all
725// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
726// then check individual metadata fields instead.
727type libraryDependencyTag struct {
728 blueprint.BaseDependencyTag
729
730 // These are exported so that fmt.Printf("%#v") can call their String methods.
731 Kind libraryDependencyKind
732 Order libraryDependencyOrder
733
734 wholeStatic bool
735
736 reexportFlags bool
737 explicitlyVersioned bool
738 dataLib bool
739 ndk bool
740
741 staticUnwinder bool
742
743 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900744
Cindy Zhou18417cb2020-12-10 07:12:38 -0800745 // Whether or not this dependency should skip the apex dependency check
746 skipApexAllowedDependenciesCheck bool
747
Jiyong Parke3867542020-12-03 17:28:25 +0900748 // Whether or not this dependency has to be followed for the apex variants
749 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900750 // Whether or not this dependency has to be followed for the non-apex variants
751 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000752
753 // If true, don't automatically export symbols from the static library into a shared library.
754 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700755}
756
757// header returns true if the libraryDependencyTag is tagging a header lib dependency.
758func (d libraryDependencyTag) header() bool {
759 return d.Kind == headerLibraryDependency
760}
761
762// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
763func (d libraryDependencyTag) shared() bool {
764 return d.Kind == sharedLibraryDependency
765}
766
767// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
768func (d libraryDependencyTag) static() bool {
769 return d.Kind == staticLibraryDependency
770}
771
Colin Cross65cb3142021-12-10 23:05:02 +0000772func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
773 if d.shared() {
774 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
775 }
776 return nil
777}
778
779var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
780
Colin Crosse9fe2942020-11-10 18:12:15 -0800781// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
782// binaries or other shared libraries are installed as dependencies.
783func (d libraryDependencyTag) InstallDepNeeded() bool {
784 return d.shared()
785}
786
787var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
788
Yu Liu67a28422024-03-05 00:36:31 +0000789func (d libraryDependencyTag) PropagateAconfigValidation() bool {
790 return d.static()
791}
792
793var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
794
Colin Crosse9fe2942020-11-10 18:12:15 -0800795// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700796// libraryDependencyTag. Each tag object is created globally and reused for multiple
797// dependencies (although since the object contains no references, assigning a tag to a
798// variable and modifying it will not modify the original). Users can compare the tag
799// returned by ctx.OtherModuleDependencyTag against the global original
800type dependencyTag struct {
801 blueprint.BaseDependencyTag
802 name string
803}
804
Colin Crosse9fe2942020-11-10 18:12:15 -0800805// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
806// libraryDependencyTag, but where the dependency needs to be installed when the parent is
807// installed.
808type installDependencyTag struct {
809 blueprint.BaseDependencyTag
810 android.InstallAlwaysNeededDependencyTag
811 name string
812}
813
Colin Crossc99deeb2016-04-11 15:06:20 -0700814var (
Colin Cross6e511a92020-07-27 21:26:48 -0700815 genSourceDepTag = dependencyTag{name: "gen source"}
816 genHeaderDepTag = dependencyTag{name: "gen header"}
817 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
818 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900819 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700820 reuseObjTag = dependencyTag{name: "reuse objects"}
821 staticVariantTag = dependencyTag{name: "static variant"}
822 vndkExtDepTag = dependencyTag{name: "vndk extends"}
823 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700824 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800825 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700826 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000827 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500828 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400829 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800830 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700831)
832
Roland Levillainf89cd092019-07-29 16:22:59 +0100833func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700834 ccLibDepTag, ok := depTag.(libraryDependencyTag)
835 return ok && ccLibDepTag.shared()
836}
837
838func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
839 ccLibDepTag, ok := depTag.(libraryDependencyTag)
840 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100841}
842
Zach Johnson3df4e632020-11-06 11:56:27 -0800843func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
844 ccLibDepTag, ok := depTag.(libraryDependencyTag)
845 return ok && ccLibDepTag.header()
846}
847
Roland Levillainf89cd092019-07-29 16:22:59 +0100848func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800849 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100850}
851
Colin Crossca860ac2016-01-04 14:34:37 -0800852// Module contains the properties and members used by all C/C++ module types, and implements
853// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500854// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
855// interface.
856//
857// To define a C/C++ related module, construct a new Module object and point its delegates to
858// type-specific structs. These delegates will be invoked to register module-specific build
859// statements which may be unique to the module type. For example, module.compiler.compile() should
860// be defined so as to register build statements which are responsible for compiling the module.
861//
862// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
863// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
864// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
865// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800866type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700867 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700868
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700869 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700870 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700871 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700872
Colin Crossca860ac2016-01-04 14:34:37 -0800873 // initialize before calling Init
Yu Liu76d94462024-10-31 23:32:36 +0000874 hod android.HostOrDeviceSupported
875 multilib android.Multilib
876 testModule bool
877 incremental bool
Colin Crossc472d572015-03-17 15:06:21 -0700878
Paul Duffina0843f62019-12-13 19:50:38 +0000879 // Allowable SdkMemberTypes of this module type.
880 sdkMemberTypes []android.SdkMemberType
881
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500882 // decorator delegates, initialize before calling Init
883 // these may contain module-specific implementations, and effectively allow for custom
884 // type-specific logic. These members may reference different objects or the same object.
885 // Functions of these decorators will be invoked to initialize and register type-specific
886 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800887 generators []Generator
888 compiler compiler
889 linker linker
890 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500891
Spandan Dase12d2522023-09-12 21:42:31 +0000892 features []feature
893 stl *stl
894 sanitize *sanitize
895 coverage *coverage
896 fuzzer *fuzzer
897 sabi *sabi
Spandan Dase12d2522023-09-12 21:42:31 +0000898 lto *lto
899 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000900 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800901
Colin Cross31076b32020-10-23 17:22:06 -0700902 library libraryInterface
903
Colin Cross635c3b02016-05-18 15:37:25 -0700904 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800905
Colin Crossb98c8b02016-07-29 13:44:28 -0700906 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700907
Yu Liue70976d2024-10-15 20:45:35 +0000908 subAndroidMkOnce map[subAndroidMkProviderInfoProducer]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800909
910 // Flags used to compile this module
911 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700912
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800913 // Shared flags among build rules of this module
914 sharedFlags SharedFlags
915
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800916 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700917 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900918
919 makeLinkType string
Jooyung Han75568392020-03-20 04:29:24 +0900920
921 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700922 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700923
924 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800925
Inseob Kim37e0bb02024-04-29 15:54:44 +0900926 logtagsPaths android.Paths
Ivan Lozanofd47b1a2024-05-17 14:13:41 -0400927
928 WholeRustStaticlib bool
Cole Faust96a692b2024-08-08 14:47:51 -0700929
930 hasAidl bool
931 hasLex bool
932 hasProto bool
933 hasRenderscript bool
934 hasSysprop bool
935 hasWinMsg bool
936 hasYacc bool
Yu Liu76d94462024-10-31 23:32:36 +0000937
938 makeVarsInfo *CcMakeVarsInfo
Colin Crossc472d572015-03-17 15:06:21 -0700939}
940
Yu Liu76d94462024-10-31 23:32:36 +0000941func (c *Module) IncrementalSupported() bool {
942 return c.incremental
943}
944
945var _ blueprint.Incremental = (*Module)(nil)
946
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200947func (c *Module) AddJSONData(d *map[string]interface{}) {
948 c.AndroidModuleBase().AddJSONData(d)
949 (*d)["Cc"] = map[string]interface{}{
950 "SdkVersion": c.SdkVersion(),
951 "MinSdkVersion": c.MinSdkVersion(),
952 "VndkVersion": c.VndkVersion(),
953 "ProductSpecific": c.ProductSpecific(),
954 "SocSpecific": c.SocSpecific(),
955 "DeviceSpecific": c.DeviceSpecific(),
956 "InProduct": c.InProduct(),
957 "InVendor": c.InVendor(),
958 "InRamdisk": c.InRamdisk(),
959 "InVendorRamdisk": c.InVendorRamdisk(),
960 "InRecovery": c.InRecovery(),
961 "VendorAvailable": c.VendorAvailable(),
962 "ProductAvailable": c.ProductAvailable(),
963 "RamdiskAvailable": c.RamdiskAvailable(),
964 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
965 "RecoveryAvailable": c.RecoveryAvailable(),
966 "OdmAvailable": c.OdmAvailable(),
967 "InstallInData": c.InstallInData(),
968 "InstallInRamdisk": c.InstallInRamdisk(),
969 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
970 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
971 "InstallInRecovery": c.InstallInRecovery(),
972 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200973 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200974 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
975 "ApexSdkVersion": c.apexSdkVersion,
Cole Faust96a692b2024-08-08 14:47:51 -0700976 "AidlSrcs": c.hasAidl,
977 "LexSrcs": c.hasLex,
978 "ProtoSrcs": c.hasProto,
979 "RenderscriptSrcs": c.hasRenderscript,
980 "SyspropSrcs": c.hasSysprop,
981 "WinMsgSrcs": c.hasWinMsg,
982 "YaccSrsc": c.hasYacc,
983 "OnlyCSrcs": !(c.hasAidl || c.hasLex || c.hasProto || c.hasRenderscript || c.hasSysprop || c.hasWinMsg || c.hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900984 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200985 }
986}
987
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500988func (c *Module) SetPreventInstall() {
989 c.Properties.PreventInstall = true
990}
991
992func (c *Module) SetHideFromMake() {
993 c.Properties.HideFromMake = true
994}
995
Ivan Lozanod7586b62021-04-01 09:49:36 -0400996func (c *Module) HiddenFromMake() bool {
997 return c.Properties.HideFromMake
998}
999
Cole Fauste8a87832024-09-11 11:35:46 -07001000func (c *Module) RequiredModuleNames(ctx android.ConfigurableEvaluatorContext) []string {
Cole Faust43ddd082024-06-17 12:32:40 -07001001 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +08001002 if c.ImageVariation().Variation == android.CoreVariation {
1003 required = append(required, c.Properties.Target.Platform.Required...)
1004 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
1005 } else if c.InRecovery() {
1006 required = append(required, c.Properties.Target.Recovery.Required...)
1007 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
1008 }
1009 return android.FirstUniqueStrings(required)
1010}
1011
Ivan Lozano52767be2019-10-18 14:49:46 -07001012func (c *Module) Toc() android.OptionalPath {
1013 if c.linker != nil {
1014 if library, ok := c.linker.(libraryInterface); ok {
1015 return library.toc()
1016 }
1017 }
1018 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
1019}
1020
1021func (c *Module) ApiLevel() string {
1022 if c.linker != nil {
1023 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001024 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001025 }
1026 }
1027 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1028}
1029
1030func (c *Module) Static() bool {
1031 if c.linker != nil {
1032 if library, ok := c.linker.(libraryInterface); ok {
1033 return library.static()
1034 }
1035 }
1036 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1037}
1038
1039func (c *Module) Shared() bool {
1040 if c.linker != nil {
1041 if library, ok := c.linker.(libraryInterface); ok {
1042 return library.shared()
1043 }
1044 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001045
Ivan Lozano52767be2019-10-18 14:49:46 -07001046 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1047}
1048
1049func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001050 if c.stl != nil {
1051 return c.stl.Properties.SelectedStl
1052 }
1053 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001054}
1055
Ivan Lozano52767be2019-10-18 14:49:46 -07001056func (c *Module) StubDecorator() bool {
1057 if _, ok := c.linker.(*stubDecorator); ok {
1058 return true
1059 }
1060 return false
1061}
1062
Yi Kong5786f5c2024-05-28 02:22:34 +09001063func (c *Module) OptimizeForSize() bool {
1064 return Bool(c.Properties.Optimize_for_size)
1065}
1066
Ivan Lozano52767be2019-10-18 14:49:46 -07001067func (c *Module) SdkVersion() string {
1068 return String(c.Properties.Sdk_version)
1069}
1070
Artur Satayev480e25b2020-04-27 18:53:18 +01001071func (c *Module) MinSdkVersion() string {
1072 return String(c.Properties.Min_sdk_version)
1073}
1074
Jiyong Park5df7bd32021-08-25 16:18:46 +09001075func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001076 if linker, ok := c.linker.(*objectLinker); ok {
1077 return linker.isCrt()
1078 }
1079 return false
1080}
1081
Jiyong Park5df7bd32021-08-25 16:18:46 +09001082func (c *Module) SplitPerApiLevel() bool {
1083 return c.canUseSdk() && c.isCrt()
1084}
1085
Colin Crossc511bc52020-04-07 16:50:32 +00001086func (c *Module) AlwaysSdk() bool {
1087 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1088}
1089
Ivan Lozano183a3212019-10-18 14:18:45 -07001090func (c *Module) CcLibrary() bool {
1091 if c.linker != nil {
1092 if _, ok := c.linker.(*libraryDecorator); ok {
1093 return true
1094 }
Colin Crossd48fe732020-09-23 20:37:24 -07001095 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1096 return true
1097 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001098 }
1099 return false
1100}
1101
1102func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001103 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001104 return true
1105 }
1106 return false
1107}
1108
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001109func (c *Module) RlibStd() bool {
1110 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1111}
1112
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001113func (c *Module) RustLibraryInterface() bool {
1114 return false
1115}
1116
Ivan Lozano0a468a42024-05-13 21:03:34 -04001117func (c *Module) CrateName() string {
1118 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1119}
1120
1121func (c *Module) ExportedCrateLinkDirs() []string {
1122 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1123}
1124
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001125func (c *Module) IsFuzzModule() bool {
1126 if _, ok := c.compiler.(*fuzzBinary); ok {
1127 return true
1128 }
1129 return false
1130}
1131
1132func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1133 return c.FuzzModule
1134}
1135
1136func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1137 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1138 return fuzzer.fuzzPackagedModule
1139 }
1140 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1141}
1142
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001143func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001144 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1145 return fuzzer.sharedLibraries
1146 }
1147 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1148}
1149
Ivan Lozano2b262972019-11-21 12:30:50 -08001150func (c *Module) NonCcVariants() bool {
1151 return false
1152}
1153
Ivan Lozano183a3212019-10-18 14:18:45 -07001154func (c *Module) SetStatic() {
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.setStatic()
1158 return
1159 }
1160 }
1161 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1162}
1163
1164func (c *Module) SetShared() {
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 library.setShared()
1168 return
1169 }
1170 }
1171 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1172}
1173
1174func (c *Module) BuildStaticVariant() bool {
1175 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001176 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001177 return library.buildStatic()
1178 }
1179 }
1180 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1181}
1182
1183func (c *Module) BuildSharedVariant() bool {
1184 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001185 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001186 return library.buildShared()
1187 }
1188 }
1189 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1190}
1191
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04001192func (c *Module) BuildRlibVariant() bool {
1193 // cc modules can never build rlib variants
1194 return false
1195}
1196
Ivan Lozano183a3212019-10-18 14:18:45 -07001197func (c *Module) Module() android.Module {
1198 return c
1199}
1200
Jiyong Parkc20eee32018-09-05 22:36:17 +09001201func (c *Module) OutputFile() android.OptionalPath {
1202 return c.outputFile
1203}
1204
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001205func (c *Module) CoverageFiles() android.Paths {
1206 if c.linker != nil {
1207 if library, ok := c.linker.(libraryInterface); ok {
1208 return library.objs().coverageFiles
1209 }
1210 }
1211 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1212}
1213
Ivan Lozano183a3212019-10-18 14:18:45 -07001214var _ LinkableInterface = (*Module)(nil)
1215
Jiyong Park719b4462019-01-13 00:39:51 +09001216func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001217 if c.linker != nil {
1218 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001219 }
1220 return nil
1221}
1222
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001223func (c *Module) CoverageOutputFile() android.OptionalPath {
1224 if c.linker != nil {
1225 return c.linker.coverageOutputFilePath()
1226 }
1227 return android.OptionalPath{}
1228}
1229
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001230func (c *Module) RelativeInstallPath() string {
1231 if c.installer != nil {
1232 return c.installer.relativeInstallPath()
1233 }
1234 return ""
1235}
1236
Jooyung Han344d5432019-08-23 11:17:39 +09001237func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001238 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001239}
1240
Colin Cross36242852017-06-23 15:06:31 -07001241func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001242 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001243 for _, generator := range c.generators {
1244 c.AddProperties(generator.GeneratorProps()...)
1245 }
Colin Crossca860ac2016-01-04 14:34:37 -08001246 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001247 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001248 }
1249 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001250 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001251 }
1252 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001253 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001254 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001255 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001256 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001257 }
Colin Cross16b23492016-01-06 14:41:07 -08001258 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001259 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001260 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001261 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001262 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001263 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001264 if c.fuzzer != nil {
1265 c.AddProperties(c.fuzzer.props()...)
1266 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001267 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001268 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001269 }
Stephen Craneba090d12017-05-09 15:44:35 -07001270 if c.lto != nil {
1271 c.AddProperties(c.lto.props()...)
1272 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001273 if c.afdo != nil {
1274 c.AddProperties(c.afdo.props()...)
1275 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001276 if c.orderfile != nil {
1277 c.AddProperties(c.orderfile.props()...)
1278 }
Colin Crossca860ac2016-01-04 14:34:37 -08001279 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001280 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001281 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001282 // Allow test-only on libraries that are not cc_test_library
1283 if c.library != nil && !c.testLibrary() {
1284 c.AddProperties(&c.sourceProperties)
1285 }
Colin Crossc472d572015-03-17 15:06:21 -07001286
Colin Cross36242852017-06-23 15:06:31 -07001287 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001288 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001289 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001290
Colin Cross36242852017-06-23 15:06:31 -07001291 return c
Colin Crossc472d572015-03-17 15:06:21 -07001292}
1293
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001294// UseVndk() returns true if this module is built against VNDK.
1295// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001296func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001297 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001298}
1299
Colin Crossc511bc52020-04-07 16:50:32 +00001300func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001301 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001302 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001303}
1304
1305func (c *Module) UseSdk() bool {
1306 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001307 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001308 }
1309 return false
1310}
1311
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001312func (c *Module) isCoverageVariant() bool {
1313 return c.coverage.Properties.IsCoverageVariant
1314}
1315
Colin Cross95f1ca02020-10-29 20:47:22 -07001316func (c *Module) IsNdk(config android.Config) bool {
1317 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001318}
1319
Colin Cross127bb8b2020-12-16 16:46:01 -08001320func (c *Module) IsLlndk() bool {
1321 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001322}
1323
Colin Cross1f3f1302021-04-26 18:37:44 -07001324func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001325 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001326 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001327}
1328
Colin Cross5271fea2021-04-27 13:06:04 -07001329func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1330 lib := moduleLibraryInterface(m)
1331 return lib != nil && (lib.hasVendorPublicLibrary())
1332}
1333
1334// IsVendorPublicLibrary returns true for vendor public libraries.
1335func (c *Module) IsVendorPublicLibrary() bool {
1336 return c.VendorProperties.IsVendorPublicLibrary
1337}
1338
Ivan Lozanof1868af2022-04-12 13:08:36 -04001339func (c *Module) IsVndkPrebuiltLibrary() bool {
1340 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1341 return true
1342 }
1343 return false
1344}
1345
1346func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1347 return c.Properties.SdkAndPlatformVariantVisibleToMake
1348}
1349
Ivan Lozanod7586b62021-04-01 09:49:36 -04001350func (c *Module) HasLlndkStubs() bool {
1351 lib := moduleLibraryInterface(c)
1352 return lib != nil && lib.hasLLNDKStubs()
1353}
1354
1355func (c *Module) StubsVersion() string {
1356 if lib, ok := c.linker.(versionedInterface); ok {
1357 return lib.stubsVersion()
1358 }
1359 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1360}
1361
Colin Cross127bb8b2020-12-16 16:46:01 -08001362// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1363// and does not set llndk.vendor_available: false.
1364func (c *Module) isImplementationForLLNDKPublic() bool {
1365 library, _ := c.library.(*libraryDecorator)
1366 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001367 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001368}
1369
Colin Cross3513fb12024-01-24 14:44:47 -08001370func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001371 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001372 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001373 }
1374 return false
1375}
1376
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001377func (c *Module) isOrderfileCompile() bool {
1378 if orderfile := c.orderfile; orderfile != nil {
1379 return orderfile.Properties.OrderfileLoad
1380 }
1381 return false
1382}
1383
Yi Kongc702ebd2022-08-19 16:02:45 +08001384func (c *Module) isCfi() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001385 return c.sanitize.isSanitizerEnabled(cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001386}
1387
Yi Konged79fa32023-06-04 17:15:42 +09001388func (c *Module) isFuzzer() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001389 return c.sanitize.isSanitizerEnabled(Fuzzer)
Yi Konged79fa32023-06-04 17:15:42 +09001390}
1391
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001392func (c *Module) isNDKStubLibrary() bool {
1393 if _, ok := c.compiler.(*stubDecorator); ok {
1394 return true
1395 }
1396 return false
1397}
1398
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001399func (c *Module) SubName() string {
1400 return c.Properties.SubName
1401}
1402
Jiyong Park25fc6a92018-11-18 18:02:45 +09001403func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001404 if lib := c.library; lib != nil {
1405 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001406 }
1407 return false
1408}
1409
1410func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001411 if lib := c.library; lib != nil {
1412 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001413 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001414 return false
1415}
1416
Alan Stokes73feba32022-11-14 12:21:24 +00001417func (c *Module) IsStubsImplementationRequired() bool {
1418 if lib := c.library; lib != nil {
1419 return lib.isStubsImplementationRequired()
1420 }
1421 return false
1422}
1423
Colin Cross0477b422020-10-13 18:43:54 -07001424// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1425// the implementation. If it is an implementation library it returns its own name.
1426func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1427 name := ctx.OtherModuleName(c)
1428 if versioned, ok := c.linker.(versionedInterface); ok {
1429 name = versioned.implementationModuleName(name)
1430 }
1431 return name
1432}
1433
Martin Stjernholm2856c662020-12-02 15:03:42 +00001434// Similar to ImplementationModuleName, but uses the Make variant of the module
1435// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1436// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1437// under the premise that the prebuilt module overrides its source counterpart
1438// if it is exposed to Make).
1439func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1440 name := c.BaseModuleName()
1441 if versioned, ok := c.linker.(versionedInterface); ok {
1442 name = versioned.implementationModuleName(name)
1443 }
1444 return name
1445}
1446
Jiyong Park7d55b612021-06-11 17:22:09 +09001447func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001448 return Bool(c.Properties.Bootstrap)
1449}
1450
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001451func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001452 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1453 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1454 return false
1455 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001456 return c.linker != nil && c.linker.nativeCoverage()
1457}
1458
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001459func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001460 if p, ok := c.linker.(SnapshotInterface); ok {
1461 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001462 }
1463 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001464}
1465
Jiyong Parkf1194352019-02-25 11:05:47 +09001466func isBionic(name string) bool {
1467 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001468 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001469 return true
1470 }
1471 return false
1472}
1473
Martin Stjernholm279de572019-09-10 23:18:20 +01001474func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001475 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001476 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001477 }
1478 return isBionic(name)
1479}
1480
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001481func (c *Module) isCfiAssemblySupportEnabled() bool {
1482 return c.sanitize != nil &&
1483 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1484}
1485
Inseob Kim800d1142021-06-14 12:03:51 +09001486func (c *Module) InstallInRoot() bool {
1487 return c.installer != nil && c.installer.installInRoot()
1488}
1489
Colin Crossca860ac2016-01-04 14:34:37 -08001490type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001491 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001492 moduleContextImpl
1493}
1494
Colin Cross37047f12016-12-13 17:06:13 -08001495type depsContext struct {
1496 android.BottomUpMutatorContext
1497 moduleContextImpl
1498}
1499
Colin Crossca860ac2016-01-04 14:34:37 -08001500type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001501 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001502 moduleContextImpl
1503}
1504
1505type moduleContextImpl struct {
1506 mod *Module
1507 ctx BaseModuleContext
1508}
1509
Colin Crossb98c8b02016-07-29 13:44:28 -07001510func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001511 return ctx.mod.toolchain(ctx.ctx)
1512}
1513
1514func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001515 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001516}
1517
1518func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001519 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001520}
1521
Colin Cross6a730042024-12-05 13:53:43 -08001522func (ctx *moduleContextImpl) staticLibrary() bool {
1523 return ctx.mod.staticLibrary()
1524}
1525
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001526func (ctx *moduleContextImpl) testBinary() bool {
1527 return ctx.mod.testBinary()
1528}
1529
Yi Kong56fc1b62022-09-06 16:24:00 +08001530func (ctx *moduleContextImpl) testLibrary() bool {
1531 return ctx.mod.testLibrary()
1532}
1533
Jiyong Park1d1119f2019-07-29 21:27:18 +09001534func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001535 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001536}
1537
Inseob Kim7f283f42020-06-01 21:53:49 +09001538func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001539 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001540}
1541
Inseob Kim1042d292020-06-01 23:23:05 +09001542func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001543 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001544}
1545
Yi Kong5786f5c2024-05-28 02:22:34 +09001546func (ctx *moduleContextImpl) optimizeForSize() bool {
1547 return ctx.mod.OptimizeForSize()
1548}
1549
Jooyung Hanccce2f22020-03-07 03:45:53 +09001550func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001551 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001552}
1553
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001554func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001555 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001556}
1557
1558func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001559 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001560 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001561 }
1562 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001563}
1564
Jiyong Parkb35a8192020-08-10 15:59:36 +09001565func (ctx *moduleContextImpl) minSdkVersion() string {
1566 ver := ctx.mod.MinSdkVersion()
1567 if ver == "apex_inherit" && !ctx.isForPlatform() {
1568 ver = ctx.apexSdkVersion().String()
1569 }
1570 if ver == "apex_inherit" || ver == "" {
1571 ver = ctx.sdkVersion()
1572 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001573
1574 if ctx.ctx.Device() {
Jooyung Hanaa2d3f52024-11-09 02:41:06 +00001575 // When building for vendor/product, use the latest _stable_ API as "current".
1576 // This is passed to clang/aidl compilers so that compiled/generated code works
1577 // with the system.
1578 if (ctx.inVendor() || ctx.inProduct()) && (ver == "" || ver == "current") {
1579 ver = ctx.ctx.Config().PlatformSdkVersion().String()
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001580 }
1581 }
1582
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001583 // For crt objects, the meaning of min_sdk_version is very different from other types of
1584 // module. For them, min_sdk_version defines the oldest version that the build system will
1585 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1586 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1587 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001588 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1589 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1590 // support such an old version. The version is set to the later version in case when the
1591 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1592 // it's for an APEX.
1593 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1594 if ctx.isForPlatform() {
1595 ver = strconv.Itoa(android.FutureApiLevelInt)
1596 } else { // for apex
1597 ver = ctx.apexSdkVersion().String()
1598 if ver == "" { // in case when min_sdk_version was not set by the APEX
1599 ver = ctx.sdkVersion()
1600 }
1601 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001602 }
1603
Jiyong Parkb35a8192020-08-10 15:59:36 +09001604 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1605 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1606 minSdkVersionInt, err2 := strconv.Atoi(ver)
1607 if err == nil && err2 == nil {
1608 if sdkVersionInt < minSdkVersionInt {
1609 return strconv.Itoa(sdkVersionInt)
1610 }
1611 }
1612 return ver
1613}
1614
1615func (ctx *moduleContextImpl) isSdkVariant() bool {
1616 return ctx.mod.IsSdkVariant()
1617}
1618
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001619func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001620 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001621}
Justin Yun8effde42017-06-23 19:24:43 +09001622
Kiyoung Kimaa394802024-01-08 12:55:45 +09001623func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1624 return ctx.mod.InVendorOrProduct()
1625}
1626
Colin Cross95f1ca02020-10-29 20:47:22 -07001627func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1628 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001629}
1630
Colin Cross127bb8b2020-12-16 16:46:01 -08001631func (ctx *moduleContextImpl) IsLlndk() bool {
1632 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001633}
1634
Colin Cross127bb8b2020-12-16 16:46:01 -08001635func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1636 return ctx.mod.isImplementationForLLNDKPublic()
1637}
1638
Colin Cross3513fb12024-01-24 14:44:47 -08001639func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1640 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001641}
1642
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001643func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1644 return ctx.mod.isOrderfileCompile()
1645}
1646
Yi Kongc702ebd2022-08-19 16:02:45 +08001647func (ctx *moduleContextImpl) isCfi() bool {
1648 return ctx.mod.isCfi()
1649}
1650
Yi Konged79fa32023-06-04 17:15:42 +09001651func (ctx *moduleContextImpl) isFuzzer() bool {
1652 return ctx.mod.isFuzzer()
1653}
1654
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001655func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1656 return ctx.mod.isNDKStubLibrary()
1657}
1658
Colin Cross5271fea2021-04-27 13:06:04 -07001659func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1660 return ctx.mod.IsVendorPublicLibrary()
1661}
1662
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001663func (ctx *moduleContextImpl) selectedStl() string {
1664 if stl := ctx.mod.stl; stl != nil {
1665 return stl.Properties.SelectedStl
1666 }
1667 return ""
1668}
1669
Ivan Lozanobd721262018-11-27 14:33:03 -08001670func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1671 return ctx.mod.linker.useClangLld(actx)
1672}
1673
Colin Crossce75d2c2016-10-06 16:12:58 -07001674func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001675 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001676}
1677
Logan Chiene274fc92019-12-03 11:18:32 -08001678func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001679 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1680 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001681}
1682
Colin Crosse07f2312020-08-13 11:24:56 -07001683func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001684 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1685 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001686}
1687
Dan Albertc8060532020-07-22 22:32:17 -07001688func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001689 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001690}
1691
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001692func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001693 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001694}
1695
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001696func (ctx *moduleContextImpl) nativeCoverage() bool {
1697 return ctx.mod.nativeCoverage()
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
Colin Cross2dcbca62024-11-20 14:55:14 -08001889 if info, ok := android.ModuleProvider(ctx, android.ApexInfoProvider); !ok || info.IsForPlatform() {
Spandan Das20fce2d2023-04-12 17:21:39 +00001890 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 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002051 }
2052
Colin Crossca860ac2016-01-04 14:34:37 -08002053 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002054 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002055 if ctx.Failed() {
2056 return
2057 }
Colin Cross635c3b02016-05-18 15:37:25 -07002058 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002059
Chris Parsons94a0bba2021-06-04 15:03:47 -04002060 c.maybeUnhideFromMake()
Colin Crossb614cd42024-10-11 12:52:21 -07002061
2062 android.SetProvider(ctx, ImplementationDepInfoProvider, &ImplementationDepInfo{
2063 ImplementationDeps: depset.New(depset.PREORDER, deps.directImplementationDeps, deps.transitiveImplementationDeps),
2064 })
Colin Crossce75d2c2016-10-06 16:12:58 -07002065 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002066
Colin Cross40213022023-12-13 15:19:49 -08002067 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002068
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002069 if Bool(c.Properties.Cmake_snapshot_supported) {
2070 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2071 }
2072
Chris Parsons94a0bba2021-06-04 15:03:47 -04002073 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002074
2075 if c.linker != nil {
2076 moduleInfoJSON := ctx.ModuleInfoJSON()
2077 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2078 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2079 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2080 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2081 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2082
2083 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2084 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2085 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2086 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2087
2088 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2089 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2090 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2091 moduleInfoJSON.SubName += ".cfi"
2092 }
2093 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2094 moduleInfoJSON.SubName += ".hwasan"
2095 }
2096 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2097 moduleInfoJSON.SubName += ".scs"
2098 }
2099 }
2100 moduleInfoJSON.SubName += c.Properties.SubName
2101
2102 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2103 moduleInfoJSON.Uninstallable = true
2104 }
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002105 }
Wei Lia1aa2972024-06-21 13:08:51 -07002106
2107 buildComplianceMetadataInfo(ctx, c, deps)
mrziwangabdb2932024-06-18 12:43:41 -07002108
Cole Faust96a692b2024-08-08 14:47:51 -07002109 if b, ok := c.compiler.(*baseCompiler); ok {
2110 c.hasAidl = b.hasSrcExt(ctx, ".aidl")
2111 c.hasLex = b.hasSrcExt(ctx, ".l") || b.hasSrcExt(ctx, ".ll")
2112 c.hasProto = b.hasSrcExt(ctx, ".proto")
2113 c.hasRenderscript = b.hasSrcExt(ctx, ".rscript") || b.hasSrcExt(ctx, ".fs")
2114 c.hasSysprop = b.hasSrcExt(ctx, ".sysprop")
2115 c.hasWinMsg = b.hasSrcExt(ctx, ".mc")
2116 c.hasYacc = b.hasSrcExt(ctx, ".y") || b.hasSrcExt(ctx, ".yy")
2117 }
2118
Yu Liuec7043d2024-11-05 18:22:20 +00002119 ccObjectInfo := CcObjectInfo{
2120 kytheFiles: objs.kytheFiles,
2121 }
2122 if !ctx.Config().KatiEnabled() || !android.ShouldSkipAndroidMkProcessing(ctx, c) {
2123 ccObjectInfo.objFiles = objs.objFiles
2124 ccObjectInfo.tidyFiles = objs.tidyFiles
2125 }
2126 if len(ccObjectInfo.kytheFiles)+len(ccObjectInfo.objFiles)+len(ccObjectInfo.tidyFiles) > 0 {
2127 android.SetProvider(ctx, CcObjectInfoProvider, ccObjectInfo)
2128 }
2129
Yu Liu986d98c2024-11-12 00:28:11 +00002130 android.SetProvider(ctx, LinkableInfoKey, LinkableInfo{
2131 StaticExecutable: c.StaticExecutable(),
2132 })
2133
Yu Liub1bfa9d2024-12-05 18:57:51 +00002134 android.SetProvider(ctx, CcInfoProvider, CcInfo{
2135 HasStubsVariants: c.HasStubsVariants(),
2136 })
2137
mrziwangabdb2932024-06-18 12:43:41 -07002138 c.setOutputFiles(ctx)
Yu Liu76d94462024-10-31 23:32:36 +00002139
2140 if c.makeVarsInfo != nil {
2141 android.SetProvider(ctx, CcMakeVarsInfoProvider, c.makeVarsInfo)
2142 }
mrziwangabdb2932024-06-18 12:43:41 -07002143}
2144
Yu Liuec7043d2024-11-05 18:22:20 +00002145func setOutputFilesIfNotEmpty(ctx ModuleContext, files android.Paths, tag string) {
2146 if len(files) > 0 {
2147 ctx.SetOutputFiles(files, tag)
2148 }
2149}
2150
mrziwangabdb2932024-06-18 12:43:41 -07002151func (c *Module) setOutputFiles(ctx ModuleContext) {
2152 if c.outputFile.Valid() {
2153 ctx.SetOutputFiles(android.Paths{c.outputFile.Path()}, "")
2154 } else {
2155 ctx.SetOutputFiles(android.Paths{}, "")
2156 }
2157 if c.linker != nil {
2158 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), "unstripped")
2159 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), "stripped_all")
2160 }
Wei Lia1aa2972024-06-21 13:08:51 -07002161}
2162
2163func buildComplianceMetadataInfo(ctx ModuleContext, c *Module, deps PathDeps) {
2164 // Dump metadata that can not be done in android/compliance-metadata.go
2165 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
2166 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.IS_STATIC_LIB, strconv.FormatBool(ctx.static()))
2167 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.BUILT_FILES, c.outputFile.String())
2168
2169 // Static deps
Yu Liuf432c2e2024-12-17 00:09:15 +00002170 staticDeps := ctx.GetDirectDepsProxyWithTag(StaticDepTag(false))
Wei Lia1aa2972024-06-21 13:08:51 -07002171 staticDepNames := make([]string, 0, len(staticDeps))
2172 for _, dep := range staticDeps {
2173 staticDepNames = append(staticDepNames, dep.Name())
2174 }
2175
2176 staticDepPaths := make([]string, 0, len(deps.StaticLibs))
2177 for _, dep := range deps.StaticLibs {
2178 staticDepPaths = append(staticDepPaths, dep.String())
2179 }
2180 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEPS, android.FirstUniqueStrings(staticDepNames))
2181 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEP_FILES, android.FirstUniqueStrings(staticDepPaths))
2182
2183 // Whole static deps
Yu Liuf432c2e2024-12-17 00:09:15 +00002184 wholeStaticDeps := ctx.GetDirectDepsProxyWithTag(StaticDepTag(true))
Wei Lia1aa2972024-06-21 13:08:51 -07002185 wholeStaticDepNames := make([]string, 0, len(wholeStaticDeps))
2186 for _, dep := range wholeStaticDeps {
2187 wholeStaticDepNames = append(wholeStaticDepNames, dep.Name())
2188 }
2189
2190 wholeStaticDepPaths := make([]string, 0, len(deps.WholeStaticLibs))
2191 for _, dep := range deps.WholeStaticLibs {
2192 wholeStaticDepPaths = append(wholeStaticDepPaths, dep.String())
2193 }
2194 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEPS, android.FirstUniqueStrings(wholeStaticDepNames))
2195 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEP_FILES, android.FirstUniqueStrings(wholeStaticDepPaths))
Chris Parsons94a0bba2021-06-04 15:03:47 -04002196}
2197
2198func (c *Module) maybeUnhideFromMake() {
2199 // If a lib is directly included in any of the APEXes or is not available to the
2200 // platform (which is often the case when the stub is provided as a prebuilt),
2201 // unhide the stubs variant having the latest version gets visible to make. In
2202 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2203 // force anything in the make world to link against the stubs library. (unless it
2204 // is explicitly referenced via .bootstrap suffix or the module is marked with
2205 // 'bootstrap: true').
2206 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002207 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002208 c.IsStubs() && !c.InVendorRamdisk() {
2209 c.Properties.HideFromMake = false // unhide
2210 // Note: this is still non-installable
2211 }
2212}
2213
Colin Cross8ff10582023-12-07 13:10:56 -08002214// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2215// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002216func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002217 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002218 // If the module has been specifically configure to not be installed then
2219 // hide from make as otherwise it will break when running inside make
2220 // as the output path to install will not be specified. Not all uninstallable
2221 // modules can be hidden from make as some are needed for resolving make side
2222 // dependencies.
2223 c.HideFromMake()
Spandan Das034af2c2024-10-30 21:45:09 +00002224 c.SkipInstall()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002225 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002226 c.SkipInstall()
2227 }
2228
2229 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2230 // to allow using the outputs in a genrule.
2231 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002232 c.installer.install(ctx, c.outputFile.Path())
2233 if ctx.Failed() {
2234 return
Colin Crossca860ac2016-01-04 14:34:37 -08002235 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002236 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002237}
2238
Colin Cross0ea8ba82019-06-06 14:33:29 -07002239func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002240 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002241 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002242 }
Colin Crossca860ac2016-01-04 14:34:37 -08002243 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002244}
2245
Colin Crossca860ac2016-01-04 14:34:37 -08002246func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002247 for _, generator := range c.generators {
2248 generator.GeneratorInit(ctx)
2249 }
Colin Crossca860ac2016-01-04 14:34:37 -08002250 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002251 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002252 }
Colin Crossca860ac2016-01-04 14:34:37 -08002253 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002254 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002255 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002256 if c.stl != nil {
2257 c.stl.begin(ctx)
2258 }
Colin Cross16b23492016-01-06 14:41:07 -08002259 if c.sanitize != nil {
2260 c.sanitize.begin(ctx)
2261 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002262 if c.coverage != nil {
2263 c.coverage.begin(ctx)
2264 }
Yi Kong9723e332023-12-04 14:52:53 +09002265 if c.afdo != nil {
2266 c.afdo.begin(ctx)
2267 }
Stephen Craneba090d12017-05-09 15:44:35 -07002268 if c.lto != nil {
2269 c.lto.begin(ctx)
2270 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002271 if c.orderfile != nil {
2272 c.orderfile.begin(ctx)
2273 }
Dan Albert92fe7402020-07-15 13:33:30 -07002274 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002275 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002276 if err != nil {
2277 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002278 c.Properties.Sdk_version = nil
2279 } else {
2280 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002281 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002282 }
Colin Crossca860ac2016-01-04 14:34:37 -08002283}
2284
Colin Cross37047f12016-12-13 17:06:13 -08002285func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002286 deps := Deps{}
2287
Joe Onorato37f900c2023-07-18 16:58:16 -07002288 for _, generator := range c.generators {
2289 deps = generator.GeneratorDeps(ctx, deps)
2290 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002291 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002292 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002293 }
2294 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002295 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002296 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002297 if c.stl != nil {
2298 deps = c.stl.deps(ctx, deps)
2299 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002300 if c.coverage != nil {
2301 deps = c.coverage.deps(ctx, deps)
2302 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002303
Colin Crossb6715442017-10-24 11:13:31 -07002304 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2305 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2306 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2307 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2308 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2309 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002310 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002311 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002312
Colin Cross516c5452024-10-28 13:45:21 -07002313 if err := checkConflictingExplicitVersions(deps.SharedLibs); err != nil {
2314 ctx.PropertyErrorf("shared_libs", "%s", err.Error())
2315 }
2316
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002317 for _, lib := range deps.ReexportSharedLibHeaders {
2318 if !inList(lib, deps.SharedLibs) {
2319 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2320 }
2321 }
2322
2323 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002324 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2325 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 -07002326 }
2327 }
2328
Colin Cross5950f382016-12-13 12:50:57 -08002329 for _, lib := range deps.ReexportHeaderLibHeaders {
2330 if !inList(lib, deps.HeaderLibs) {
2331 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2332 }
2333 }
2334
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002335 for _, gen := range deps.ReexportGeneratedHeaders {
2336 if !inList(gen, deps.GeneratedHeaders) {
2337 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2338 }
2339 }
2340
Colin Crossc99deeb2016-04-11 15:06:20 -07002341 return deps
2342}
2343
Colin Cross516c5452024-10-28 13:45:21 -07002344func checkConflictingExplicitVersions(libs []string) error {
2345 withoutVersion := func(s string) string {
2346 name, _ := StubsLibNameAndVersion(s)
2347 return name
2348 }
2349 var errs []error
2350 for i, lib := range libs {
2351 libName := withoutVersion(lib)
2352 libsToCompare := libs[i+1:]
2353 j := slices.IndexFunc(libsToCompare, func(s string) bool {
2354 return withoutVersion(s) == libName
2355 })
2356 if j >= 0 {
2357 errs = append(errs, fmt.Errorf("duplicate shared libraries with different explicit versions: %q and %q",
2358 lib, libsToCompare[j]))
2359 }
2360 }
2361 return errors.Join(errs...)
2362}
2363
Dan Albert7e9d2952016-08-04 13:02:36 -07002364func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002365 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002366 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002367 moduleContextImpl: moduleContextImpl{
2368 mod: c,
2369 },
2370 }
2371 ctx.ctx = ctx
2372
Colin Crossca860ac2016-01-04 14:34:37 -08002373 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002374}
2375
Jiyong Park7ed9de32018-10-15 22:25:07 +09002376// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002377func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002378 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2379 version := name[sharp+1:]
2380 libname := name[:sharp]
2381 return libname, version
2382 }
2383 return name, ""
2384}
2385
Dan Albert92fe7402020-07-15 13:33:30 -07002386func GetCrtVariations(ctx android.BottomUpMutatorContext,
2387 m LinkableInterface) []blueprint.Variation {
2388 if ctx.Os() != android.Android {
2389 return nil
2390 }
2391 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002392 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2393 minSdkVersion := m.MinSdkVersion()
2394 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2395 minSdkVersion = m.SdkVersion()
2396 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002397 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2398 if err != nil {
2399 ctx.PropertyErrorf("min_sdk_version", err.Error())
2400 }
Colin Cross363ec762023-01-13 13:45:14 -08002401
2402 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002403 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002404 if apiLevel.LessThan(minApiForArch) {
2405 apiLevel = minApiForArch
2406 }
2407
Dan Albert92fe7402020-07-15 13:33:30 -07002408 return []blueprint.Variation{
2409 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002410 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002411 }
2412 }
2413 return []blueprint.Variation{
2414 {Mutator: "sdk", Variation: ""},
2415 }
2416}
2417
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002418func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2419 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002420
2421 variations = append([]blueprint.Variation(nil), variations...)
2422
Liz Kammer23942242022-04-08 15:41:00 -04002423 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002424 // Version is explicitly specified. i.e. libFoo#30
Colin Crossb614cd42024-10-11 12:52:21 -07002425 if version == "impl" {
2426 version = ""
2427 }
Colin Crosse7257d22020-09-24 09:56:18 -07002428 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002429 if tag, ok := depTag.(libraryDependencyTag); ok {
2430 tag.explicitlyVersioned = true
Colin Crossafcdce82024-10-22 13:59:33 -07002431 // depTag is an interface that contains a concrete non-pointer struct. That makes the local
2432 // tag variable a copy of the contents of depTag, and updating it doesn't change depTag. Reassign
2433 // the modified copy to depTag.
2434 depTag = tag
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002435 } else {
2436 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2437 }
Colin Crosse7257d22020-09-24 09:56:18 -07002438 }
Colin Crosse7257d22020-09-24 09:56:18 -07002439
Colin Cross0de8a1e2020-09-18 14:15:30 -07002440 if far {
2441 ctx.AddFarVariationDependencies(variations, depTag, name)
2442 } else {
2443 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002444 }
2445}
2446
Kiyoung Kim487689e2022-07-26 09:48:22 +09002447func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2448 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002449 return snapshot
2450 }
2451
2452 return lib
2453}
2454
Kiyoung Kim37693d02024-04-04 09:56:15 +09002455// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002456// of names:
2457//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002458// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002459//
2460// For each of these, it adds the name of the ndk_library module to the list of
2461// variant libs.
2462//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002463// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002464//
2465// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002466//
2467// The caller can then know to add the variantLibs dependencies differently from the
2468// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002469func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002470 variantLibs = []string{}
2471
2472 nonvariantLibs = []string{}
2473 for _, entry := range list {
2474 // strip #version suffix out
2475 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002476 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002477 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002478 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002479 nonvariantLibs = append(nonvariantLibs, entry)
2480 }
2481 }
2482 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002483
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002484}
2485
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002486func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2487 nonVariantLibs := []string{}
2488 variantLibs := []string{}
2489
2490 for _, lib := range libs {
2491 replaceLibName := GetReplaceModuleName(lib, replaceList)
2492 if replaceLibName == lib {
2493 // Do not handle any libs which are not in API imports
2494 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2495 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2496 variantLibs = append(variantLibs, replaceLibName)
2497 } else {
2498 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2499 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002500 }
2501
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002502 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002503}
2504
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002505func (c *Module) shouldUseApiSurface() bool {
2506 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2507 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2508 // LLNDK Variant
2509 return true
2510 }
2511
2512 if c.Properties.IsSdkVariant {
2513 // NDK Variant
2514 return true
2515 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002516 }
2517
2518 return false
2519}
2520
Colin Cross1e676be2016-10-12 14:38:15 -07002521func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002522 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002523 return
2524 }
2525
Colin Cross37047f12016-12-13 17:06:13 -08002526 ctx := &depsContext{
2527 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002528 moduleContextImpl: moduleContextImpl{
2529 mod: c,
2530 },
2531 }
2532 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002533
Colin Crossc99deeb2016-04-11 15:06:20 -07002534 deps := c.deps(ctx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002535
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002536 apiNdkLibs := []string{}
2537 apiLateNdkLibs := []string{}
2538
Yo Chiang219968c2020-09-22 18:45:04 +08002539 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2540
Dan Albert914449f2016-06-17 16:45:24 -07002541 variantNdkLibs := []string{}
2542 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002543 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002544 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2545 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2546 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002547 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002548
Colin Cross32ec36c2016-12-15 07:39:51 -08002549 for _, lib := range deps.HeaderLibs {
Colin Cross8acea3e2024-12-12 14:53:30 -08002550 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002551 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002552 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002553 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002554
Spandan Das73bcafc2022-08-18 23:26:00 +00002555 if c.isNDKStubLibrary() {
Jiyong Parkf8fab9b2024-09-02 15:24:15 +09002556 variationExists := actx.OtherModuleDependencyVariantExists(nil, lib)
2557 if variationExists {
2558 actx.AddVariationDependencies(nil, depTag, lib)
2559 } else {
2560 // dependencies to ndk_headers fall here as ndk_headers do not have
2561 // any variants.
2562 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
2563 }
Spandan Dasff665182024-09-11 18:48:44 +00002564 } else if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002565 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002566 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002567 } else {
2568 actx.AddVariationDependencies(nil, depTag, lib)
2569 }
2570 }
2571
Dan Albertf1d14c72020-07-30 14:32:55 -07002572 if c.isNDKStubLibrary() {
2573 // NDK stubs depend on their implementation because the ABI dumps are
2574 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002575
Spandan Das8b08aea2023-03-14 19:29:34 +00002576 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2577 c.ImageVariation(),
2578 blueprint.Variation{Mutator: "link", Variation: "shared"},
2579 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002580 }
2581
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002582 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2583 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2584 c.Target().NativeBridge == android.NativeBridgeDisabled {
2585 actx.AddVariationDependencies(
Jihoon Kang47e91842024-06-19 00:51:16 +00002586 []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}},
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002587 llndkHeaderLibTag,
2588 deps.LlndkHeaderLibs...)
2589 }
2590
Jiyong Park5d1598f2019-02-25 22:14:17 +09002591 for _, lib := range deps.WholeStaticLibs {
Colin Cross8acea3e2024-12-12 14:53:30 -08002592 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002593
Jiyong Park5d1598f2019-02-25 22:14:17 +09002594 actx.AddVariationDependencies([]blueprint.Variation{
2595 {Mutator: "link", Variation: "static"},
2596 }, depTag, lib)
2597 }
2598
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002599 for _, lib := range deps.StaticLibs {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002600 // Some dependencies listed in static_libs might actually be rust_ffi rlib variants.
Colin Cross8acea3e2024-12-12 14:53:30 -08002601 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002602
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002603 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002604 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002605 }
Jiyong Parke3867542020-12-03 17:28:25 +09002606 if inList(lib, deps.ExcludeLibsForApex) {
2607 depTag.excludeInApex = true
2608 }
Dan Willemsen59339a22018-07-22 21:18:45 -07002609 actx.AddVariationDependencies([]blueprint.Variation{
2610 {Mutator: "link", Variation: "static"},
2611 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002612 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002613
Jooyung Han75568392020-03-20 04:29:24 +09002614 // staticUnwinderDep is treated as staticDep for Q apexes
2615 // so that native libraries/binaries are linked with static unwinder
2616 // because Q libc doesn't have unwinder APIs
2617 if deps.StaticUnwinderIfLegacy {
Colin Cross8acea3e2024-12-12 14:53:30 -08002618 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002619 actx.AddVariationDependencies([]blueprint.Variation{
2620 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002621 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002622 }
2623
Jiyong Park7ed9de32018-10-15 22:25:07 +09002624 // shared lib names without the #version suffix
2625 var sharedLibNames []string
2626
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002627 for _, lib := range deps.SharedLibs {
Colin Cross8acea3e2024-12-12 14:53:30 -08002628 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002629 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002630 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002631 }
Jiyong Parke3867542020-12-03 17:28:25 +09002632 if inList(lib, deps.ExcludeLibsForApex) {
2633 depTag.excludeInApex = true
2634 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002635 if inList(lib, deps.ExcludeLibsForNonApex) {
2636 depTag.excludeInNonApex = true
2637 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002638
Jiyong Park73c54ee2019-10-22 20:31:18 +09002639 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002640 sharedLibNames = append(sharedLibNames, name)
2641
Colin Crosse7257d22020-09-24 09:56:18 -07002642 variations := []blueprint.Variation{
2643 {Mutator: "link", Variation: "shared"},
2644 }
Spandan Dasff665182024-09-11 18:48:44 +00002645 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002646 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002647
Colin Crossfe9acfe2021-06-14 16:13:03 -07002648 for _, lib := range deps.LateStaticLibs {
Colin Cross8acea3e2024-12-12 14:53:30 -08002649 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
Colin Crossfe9acfe2021-06-14 16:13:03 -07002650 actx.AddVariationDependencies([]blueprint.Variation{
2651 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002652 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002653 }
2654
Colin Cross3e5e7782022-06-17 22:17:05 +00002655 for _, lib := range deps.UnexportedStaticLibs {
Colin Cross8acea3e2024-12-12 14:53:30 -08002656 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
Colin Cross3e5e7782022-06-17 22:17:05 +00002657 actx.AddVariationDependencies([]blueprint.Variation{
2658 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002659 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002660 }
2661
Jiyong Park7ed9de32018-10-15 22:25:07 +09002662 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002663 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002664 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2665 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2666 // linking against both the stubs lib and the non-stubs lib at the same time.
2667 continue
2668 }
Colin Cross8acea3e2024-12-12 14:53:30 -08002669 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002670 variations := []blueprint.Variation{
2671 {Mutator: "link", Variation: "shared"},
2672 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002673 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002674 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002675
Dan Willemsen59339a22018-07-22 21:18:45 -07002676 actx.AddVariationDependencies([]blueprint.Variation{
2677 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002678 }, dataLibDepTag, deps.DataLibs...)
2679
Colin Crossc8caa062021-09-24 16:50:14 -07002680 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2681
Chris Parsons79d66a52020-06-05 17:26:16 -04002682 actx.AddVariationDependencies([]blueprint.Variation{
2683 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002684 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002685
Colin Cross68861832016-07-08 10:41:41 -07002686 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002687
2688 for _, gen := range deps.GeneratedHeaders {
2689 depTag := genHeaderDepTag
2690 if inList(gen, deps.ReexportGeneratedHeaders) {
2691 depTag = genHeaderExportDepTag
2692 }
2693 actx.AddDependency(c, depTag, gen)
2694 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002695
Cole Faust65cb40a2024-10-21 15:41:42 -07002696 for _, gen := range deps.DeviceFirstGeneratedHeaders {
2697 depTag := genHeaderDepTag
2698 actx.AddVariationDependencies(ctx.Config().AndroidFirstDeviceTarget.Variations(), depTag, gen)
2699 }
2700
Dan Albert92fe7402020-07-15 13:33:30 -07002701 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002702 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002703 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002704 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002705 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002706 }
Colin Crossc465efd2021-06-11 18:00:04 -07002707 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002708 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002709 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002710 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002711 if deps.DynamicLinker != "" {
2712 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002713 }
Dan Albert914449f2016-06-17 16:45:24 -07002714
2715 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002716
Colin Cross8acea3e2024-12-12 14:53:30 -08002717 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002718 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002719 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002720 {Mutator: "link", Variation: "shared"},
2721 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002722 actx.AddVariationDependencies([]blueprint.Variation{
2723 {Mutator: "version", Variation: version},
2724 {Mutator: "link", Variation: "shared"},
2725 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002726
Colin Cross8acea3e2024-12-12 14:53:30 -08002727 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002728 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002729 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002730 {Mutator: "link", Variation: "shared"},
2731 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002732 actx.AddVariationDependencies([]blueprint.Variation{
2733 {Mutator: "version", Variation: version},
2734 {Mutator: "link", Variation: "shared"},
2735 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002736
Vinh Tran367d89d2023-04-28 11:21:25 -04002737 if len(deps.AidlLibs) > 0 {
2738 actx.AddDependency(
2739 c,
2740 aidlLibraryTag,
2741 deps.AidlLibs...,
2742 )
2743 }
2744
Colin Cross6362e272015-10-29 15:25:03 -07002745}
Colin Cross21b9a242015-03-24 14:15:58 -07002746
Colin Crosse40b4ea2018-10-02 22:25:58 -07002747func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002748 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002749 c.beginMutator(ctx)
2750 }
2751}
2752
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002753// Whether a module can link to another module, taking into
2754// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002755func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002756 tag blueprint.DependencyTag) {
2757
2758 switch t := tag.(type) {
2759 case dependencyTag:
2760 if t != vndkExtDepTag {
2761 return
2762 }
2763 case libraryDependencyTag:
2764 default:
2765 return
2766 }
2767
Ivan Lozanof9e21722020-12-02 09:00:51 -05002768 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002769 // Host code is not restricted
2770 return
2771 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002772
Ivan Lozano52767be2019-10-18 14:49:46 -07002773 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002774 // Platform code can link to anything
2775 return
2776 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002777 if from.InRamdisk() {
2778 // Ramdisk code is not NDK
2779 return
2780 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002781 if from.InVendorRamdisk() {
2782 // Vendor ramdisk code is not NDK
2783 return
2784 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002785 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002786 // Recovery code is not NDK
2787 return
2788 }
Colin Cross31076b32020-10-23 17:22:06 -07002789 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002790 if c.StubDecorator() {
2791 // These aren't real libraries, but are the stub shared libraries that are included in
2792 // the NDK.
2793 return
2794 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002795 }
Logan Chien834b9a62019-01-14 15:39:03 +08002796
Ivan Lozano52767be2019-10-18 14:49:46 -07002797 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002798 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2799 // to link to libc++ (non-NDK and without sdk_version).
2800 return
2801 }
2802
Ivan Lozano52767be2019-10-18 14:49:46 -07002803 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002804 // NDK code linking to platform code is never okay.
2805 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002806 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002807 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002808 }
2809
2810 // At this point we know we have two NDK libraries, but we need to
2811 // check that we're not linking against anything built against a higher
2812 // API level, as it is only valid to link against older or equivalent
2813 // APIs.
2814
Inseob Kim01a28722018-04-11 09:48:45 +09002815 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002816 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002817 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002818 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002819 // Current can't be linked against by anything else.
2820 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002821 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002822 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002823 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002824 if err != nil {
2825 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002826 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002827 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002828 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002829 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002830 if err != nil {
2831 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002832 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002833 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002834 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002835
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002836 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002837 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002838 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002839 }
2840 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002841 }
Dan Albert202fe492017-12-15 13:56:59 -08002842
2843 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002844 fromStl := from.SelectedStl()
2845 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002846 if fromStl == "" || toStl == "" {
2847 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002848 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002849 // We can be permissive with the system "STL" since it is only the C++
2850 // ABI layer, but in the future we should make sure that everyone is
2851 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002852 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002853 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002854 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2855 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002856 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002857}
2858
Jooyung Han479ca172020-10-19 18:51:07 +09002859func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2860 if c, ok := ctx.Module().(*Module); ok {
2861 ctx.VisitDirectDeps(func(dep android.Module) {
2862 depTag := ctx.OtherModuleDependencyTag(dep)
2863 ccDep, ok := dep.(LinkableInterface)
2864 if ok {
2865 checkLinkType(ctx, c, ccDep, depTag)
2866 }
2867 })
2868 }
2869}
2870
Jiyong Park5fb8c102018-04-09 12:03:06 +09002871// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002872// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2873// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002874// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Colin Crossda279cf2024-09-17 14:25:45 -07002875func checkDoubleLoadableLibraries(ctx android.BottomUpMutatorContext) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002876 check := func(child, parent android.Module) bool {
2877 to, ok := child.(*Module)
2878 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002879 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002880 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002881
Jooyung Hana70f0672019-01-18 15:20:43 +09002882 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2883 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002884 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002885
Jiyong Park0474e1f2021-01-14 14:26:06 +09002886 // These dependencies are not excercised at runtime. Tracking these will give us
2887 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002888 depTag := ctx.OtherModuleDependencyTag(child)
2889 if IsHeaderDepTag(depTag) {
2890 return false
2891 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002892 if depTag == staticVariantTag {
2893 return false
2894 }
2895 if depTag == stubImplDepTag {
2896 return false
2897 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002898 if depTag == android.RequiredDepTag {
2899 return false
2900 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002901
Justin Yun63e9ec72020-10-29 16:49:43 +09002902 // Even if target lib has no vendor variant, keep checking dependency
2903 // graph in case it depends on vendor_available or product_available
2904 // but not double_loadable transtively.
2905 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002906 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002907 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002908
Jiyong Park0474e1f2021-01-14 14:26:06 +09002909 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2910 // one.
2911 if Bool(to.VendorProperties.Double_loadable) {
2912 return true
2913 }
2914
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002915 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002916 return false
2917 }
2918
Jooyung Hana70f0672019-01-18 15:20:43 +09002919 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2920 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002921 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002922 return false
2923 }
2924 if module, ok := ctx.Module().(*Module); ok {
2925 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002926 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002927 ctx.WalkDeps(check)
2928 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002929 }
2930 }
2931}
2932
Yu Liue4312402023-01-18 09:15:31 -08002933func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2934 // For the dependency from platform to apex, use the latest stubs
2935 apexSdkVersion := android.FutureApiLevel
2936 if !apexInfo.IsForPlatform() {
2937 apexSdkVersion = apexInfo.MinSdkVersion
2938 }
2939
2940 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2941 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2942 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2943 // (b/144430859)
2944 apexSdkVersion = android.FutureApiLevel
2945 }
2946
2947 return apexSdkVersion
2948}
2949
Colin Crossc99deeb2016-04-11 15:06:20 -07002950// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002951func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002952 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002953
Colin Cross0de8a1e2020-09-18 14:15:30 -07002954 var directStaticDeps []StaticLibraryInfo
2955 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002956
Colin Cross0de8a1e2020-09-18 14:15:30 -07002957 reexportExporter := func(exporter FlagExporterInfo) {
2958 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2959 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2960 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2961 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2962 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002963 }
2964
Colin Crossff694a82023-12-13 15:54:49 -08002965 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002966 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002967
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002968 skipModuleList := map[string]bool{}
2969
Colin Crossd11fcda2017-10-23 17:59:01 -07002970 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002971 depName := ctx.OtherModuleName(dep)
2972 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002973
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002974 if _, ok := skipModuleList[depName]; ok {
2975 // skip this module because original module or API imported module matching with this should be used instead.
2976 return
2977 }
2978
Dan Willemsen47450072021-10-19 20:24:49 -07002979 if depTag == android.DarwinUniversalVariantTag {
2980 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2981 return
2982 }
2983
Vinh Tran367d89d2023-04-28 11:21:25 -04002984 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08002985 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04002986 depPaths.AidlLibraryInfos = append(
2987 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08002988 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04002989 )
2990 }
2991 }
2992
Ivan Lozano52767be2019-10-18 14:49:46 -07002993 ccDep, ok := dep.(LinkableInterface)
2994 if !ok {
2995
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002996 // handling for a few module types that aren't cc Module but that are also supported
2997 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002998 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002999 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003000 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3001 genRule.GeneratedSourceFiles()...)
3002 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003003 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003004 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003005 // Support exported headers from a generated_sources dependency
3006 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003007 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003008 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003009 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003010 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003011 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003012 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003013 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003014 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003015 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3016 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003017 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003018 // 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 +09003019 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003020
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003021 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003022 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003023 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003024 }
Colin Crosscef792e2021-06-11 18:01:26 -07003025 case CrtBeginDepTag:
3026 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3027 case CrtEndDepTag:
3028 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003029 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003030 return
3031 }
3032
Colin Crossfe17f6f2019-03-28 19:30:56 -07003033 if depTag == android.ProtoPluginDepTag {
3034 return
3035 }
3036
Jiyong Park8bcf3c62024-03-18 18:37:10 +09003037 if depTag == android.RequiredDepTag {
3038 return
3039 }
3040
Colin Crossd11fcda2017-10-23 17:59:01 -07003041 if dep.Target().Os != ctx.Os() {
Steven Morelandaaae81f2024-08-27 22:55:48 +00003042 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 -07003043 return
3044 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003045 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003046 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3047 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003048 return
3049 }
3050
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003051 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003052 // Skip reused objects for stub libraries, they use their own stub object file instead.
3053 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3054 // version mutator, so the stubs variant is created from the shared variant that
3055 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003056 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003057 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003058 objs := staticAnalogue.ReuseObjects
3059 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003060 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003061 reexportExporter(depExporterInfo)
3062 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003063 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003064 }
3065
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08003066 if depTag == llndkHeaderLibTag {
3067 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3068 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
3069 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3070 }
3071
Colin Cross6e511a92020-07-27 21:26:48 -07003072 linkFile := ccDep.OutputFile()
3073
3074 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3075 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003076 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003077 return
3078 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003079
Jiyong Parke3867542020-12-03 17:28:25 +09003080 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3081 return
3082 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003083 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3084 return
3085 }
Jiyong Parke3867542020-12-03 17:28:25 +09003086
Colin Cross313aa542023-12-13 13:47:44 -08003087 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003088
Colin Cross6e511a92020-07-27 21:26:48 -07003089 var ptr *android.Paths
3090 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003091
Colin Cross6e511a92020-07-27 21:26:48 -07003092 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003093
Colin Cross6e511a92020-07-27 21:26:48 -07003094 switch {
3095 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003096 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003097 if !ctx.Config().AllowMissingDependencies() {
3098 ctx.ModuleErrorf("module %q is not a header library", depName)
3099 } else {
3100 ctx.AddMissingDependencies([]string{depName})
3101 }
3102 return
3103 }
Colin Cross6e511a92020-07-27 21:26:48 -07003104 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003105 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003106 if !ctx.Config().AllowMissingDependencies() {
3107 ctx.ModuleErrorf("module %q is not a shared library", depName)
3108 } else {
3109 ctx.AddMissingDependencies([]string{depName})
3110 }
3111 return
3112 }
Jiyong Parke3867542020-12-03 17:28:25 +09003113
Jiyong Park7d55b612021-06-11 17:22:09 +09003114 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3115 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003116
Jiyong Park1ad8e162020-12-01 23:40:09 +09003117 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3118 // linkFile, depFile, and ptr.
3119 if c.IsStubs() {
3120 break
3121 }
3122
Colin Cross0de8a1e2020-09-18 14:15:30 -07003123 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3124 depFile = sharedLibraryInfo.TableOfContents
3125
Colin Crossb614cd42024-10-11 12:52:21 -07003126 if !sharedLibraryInfo.IsStubs {
3127 depPaths.directImplementationDeps = append(depPaths.directImplementationDeps, android.OutputFileForModule(ctx, dep, ""))
3128 if info, ok := android.OtherModuleProvider(ctx, dep, ImplementationDepInfoProvider); ok {
3129 depPaths.transitiveImplementationDeps = append(depPaths.transitiveImplementationDeps, info.ImplementationDeps)
3130 }
3131 }
3132
Colin Cross6e511a92020-07-27 21:26:48 -07003133 ptr = &depPaths.SharedLibs
3134 switch libDepTag.Order {
3135 case earlyLibraryDependency:
3136 ptr = &depPaths.EarlySharedLibs
3137 depPtr = &depPaths.EarlySharedLibsDeps
3138 case normalLibraryDependency:
3139 ptr = &depPaths.SharedLibs
3140 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003141 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003142 case lateLibraryDependency:
3143 ptr = &depPaths.LateSharedLibs
3144 depPtr = &depPaths.LateSharedLibsDeps
3145 default:
3146 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003147 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003148
Colin Cross6e511a92020-07-27 21:26:48 -07003149 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003150 if ccDep.RustLibraryInterface() {
3151 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3152 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3153 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3154 if libDepTag.wholeStatic {
3155 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3156 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
Jiyong Park1ad8e162020-12-01 23:40:09 +09003157
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003158 // If whole_static, track this as we want to make sure that in a final linkage for a shared library,
3159 // exported functions from the rust generated staticlib still exported.
3160 if c.CcLibrary() && c.Shared() {
3161 c.WholeRustStaticlib = true
3162 }
Colin Cross6e511a92020-07-27 21:26:48 -07003163 }
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003164
Colin Cross6e511a92020-07-27 21:26:48 -07003165 } else {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003166 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3167 if !isStaticLib {
3168 if !ctx.Config().AllowMissingDependencies() {
3169 ctx.ModuleErrorf("module %q is not a static library", depName)
3170 } else {
3171 ctx.AddMissingDependencies([]string{depName})
3172 }
3173 return
Inseob Kimeec88e12020-01-22 11:11:29 +09003174 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003175
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003176 // Stubs lib doesn't link to the static lib dependencies. Don't set
3177 // linkFile, depFile, and ptr.
3178 if c.IsStubs() {
3179 break
3180 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003181
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003182 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
3183 if libDepTag.wholeStatic {
3184 ptr = &depPaths.WholeStaticLibs
3185 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3186 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
3187 } else {
3188 // This case normally catches prebuilt static
3189 // libraries, but it can also occur when
3190 // AllowMissingDependencies is on and the
3191 // dependencies has no sources of its own
3192 // but has a whole_static_libs dependency
3193 // on a missing library. We want to depend
3194 // on the .a file so that there is something
3195 // in the dependency tree that contains the
3196 // error rule for the missing transitive
3197 // dependency.
3198 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
3199 }
3200 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3201 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
3202 } else {
3203 switch libDepTag.Order {
3204 case earlyLibraryDependency:
3205 panic(fmt.Errorf("early static libs not supported"))
3206 case normalLibraryDependency:
3207 // static dependencies will be handled separately so they can be ordered
3208 // using transitive dependencies.
3209 ptr = nil
3210 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
3211 case lateLibraryDependency:
3212 ptr = &depPaths.LateStaticLibs
3213 default:
3214 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
3215 }
3216 }
3217
3218 // Collect any exported Rust rlib deps from static libraries which have been included as whole_static_libs
3219 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3220
3221 if libDepTag.unexportedSymbols {
3222 depPaths.LdFlags = append(depPaths.LdFlags,
3223 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3224 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003225 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003226 }
3227
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003228 if libDepTag.static() && !libDepTag.wholeStatic && !ccDep.RustLibraryInterface() {
Colin Cross6e511a92020-07-27 21:26:48 -07003229 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3230 ctx.ModuleErrorf("module %q not a static library", depName)
3231 return
3232 }
Logan Chien43d34c32017-12-20 01:17:32 +08003233
Colin Cross6e511a92020-07-27 21:26:48 -07003234 // When combining coverage files for shared libraries and executables, coverage files
3235 // in static libraries act as if they were whole static libraries. The same goes for
3236 // source based Abi dump files.
3237 if c, ok := ccDep.(*Module); ok {
3238 staticLib := c.linker.(libraryInterface)
3239 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3240 staticLib.objs().coverageFiles...)
3241 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3242 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003243 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003244 // Handle non-CC modules here
3245 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003246 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003247 }
3248 }
3249
Colin Cross6e511a92020-07-27 21:26:48 -07003250 if ptr != nil {
3251 if !linkFile.Valid() {
3252 if !ctx.Config().AllowMissingDependencies() {
3253 ctx.ModuleErrorf("module %q missing output file", depName)
3254 } else {
3255 ctx.AddMissingDependencies([]string{depName})
3256 }
3257 return
3258 }
3259 *ptr = append(*ptr, linkFile.Path())
3260 }
3261
3262 if depPtr != nil {
3263 dep := depFile
3264 if !dep.Valid() {
3265 dep = linkFile
3266 }
3267 *depPtr = append(*depPtr, dep.Path())
3268 }
3269
Colin Cross0de8a1e2020-09-18 14:15:30 -07003270 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3271 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3272 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3273 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003274 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3275
3276 // Only re-export RustRlibDeps for cc static libs
3277 if c.static() {
3278 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3279 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003280
3281 if libDepTag.reexportFlags {
3282 reexportExporter(depExporterInfo)
3283 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3284 // Re-exported shared library headers must be included as well since they can help us with type information
3285 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003286 c.sabi.Properties.ReexportedIncludes = append(
3287 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003288 c.sabi.Properties.ReexportedSystemIncludes = append(
3289 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003290 }
3291
Spandan Das3faa7922024-02-26 19:42:32 +00003292 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003293 switch {
3294 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003295 c.Properties.AndroidMkHeaderLibs = append(
3296 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003297 case libDepTag.shared():
Colin Cross6e511a92020-07-27 21:26:48 -07003298 // Note: the order of libs in this list is not important because
3299 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003300 c.Properties.AndroidMkSharedLibs = append(
3301 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003302 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003303 if !ccDep.RustLibraryInterface() {
3304 if libDepTag.wholeStatic {
3305 c.Properties.AndroidMkWholeStaticLibs = append(
3306 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3307 } else {
3308 c.Properties.AndroidMkStaticLibs = append(
3309 c.Properties.AndroidMkStaticLibs, makeLibName)
3310 }
Colin Cross6e511a92020-07-27 21:26:48 -07003311 }
3312 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003313 } else if !c.IsStubs() {
3314 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3315
Colin Cross6e511a92020-07-27 21:26:48 -07003316 switch depTag {
3317 case runtimeDepTag:
3318 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003319 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003320 case objDepTag:
3321 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3322 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003323 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003324 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003325 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003326 case dynamicLinkerDepTag:
3327 depPaths.DynamicLinker = linkFile
3328 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003329 }
Colin Crossca860ac2016-01-04 14:34:37 -08003330 })
3331
Jeff Gaston294356f2017-09-27 17:05:30 -07003332 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003333 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3334 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3335 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003336
Colin Crossdd84e052017-05-17 13:44:16 -07003337 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003338 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003339 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3340 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003341 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003342 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3343
Jiyong Park74955042019-10-22 20:19:51 +09003344 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3345 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003346 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003347 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003348 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003349 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003350
3351 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003352 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003353 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003354 }
Colin Crossdd84e052017-05-17 13:44:16 -07003355
Colin Crossca860ac2016-01-04 14:34:37 -08003356 return depPaths
3357}
3358
Spandan Das10c41362024-12-03 01:33:09 +00003359func ShouldUseStubForApex(ctx android.ModuleContext, parent, dep android.Module) bool {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003360 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003361 bootstrap := false
Spandan Das10c41362024-12-03 01:33:09 +00003362 if linkable, ok := parent.(LinkableInterface); !ok {
3363 ctx.ModuleErrorf("Not a Linkable module: %q", ctx.ModuleName())
Jiyong Park7d55b612021-06-11 17:22:09 +09003364 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003365 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003366 bootstrap = linkable.Bootstrap()
3367 }
3368
Spandan Das10c41362024-12-03 01:33:09 +00003369 apexInfo, _ := android.OtherModuleProvider(ctx, parent, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003370
3371 useStubs := false
3372
Kiyoung Kimaa394802024-01-08 12:55:45 +09003373 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003374 if !apexInfo.IsForPlatform() {
3375 // For platform libraries, use current version of LLNDK
3376 // If this is for use_vendor apex we will apply the same rules
3377 // of apex sdk enforcement below to choose right version.
3378 useStubs = true
3379 }
3380 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3381 // If not building for APEX or the containing APEX allows the use of
3382 // platform APIs, use stubs only when it is from an APEX (and not from
3383 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3384 // bootstrap modules, always link to non-stub variant
3385 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3386
Spandan Dasff665182024-09-11 18:48:44 +00003387 useStubs = isNotInPlatform && !bootstrap
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003388 } else {
Colin Crossea91a172024-11-05 16:14:05 -08003389 // If building for APEX, always use stubs (can be bypassed by depending on <dep>#impl)
3390 useStubs = true
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003391 }
3392
3393 return useStubs
3394}
3395
3396// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3397// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3398// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3399// has different level of updatability. For example, if a library foo in an APEX depends on a
3400// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3401// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3402// same APEX as foo, the non-stub variant of bar is used.
3403func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3404 depTag := ctx.OtherModuleDependencyTag(dep)
3405 libDepTag, ok := depTag.(libraryDependencyTag)
3406 if !ok || !libDepTag.shared() {
3407 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3408 }
3409
Colin Cross313aa542023-12-13 13:47:44 -08003410 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3411 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3412 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003413
3414 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003415 // when to use (unspecified) stubs, use the latest one.
Spandan Das10c41362024-12-03 01:33:09 +00003416 if ShouldUseStubForApex(ctx, ctx.Module(), dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003417 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3418 toUse := stubs[len(stubs)-1]
3419 sharedLibraryInfo = toUse.SharedLibraryInfo
3420 depExporterInfo = toUse.FlagExporterInfo
3421 }
3422 }
3423 return sharedLibraryInfo, depExporterInfo
3424}
3425
Colin Cross0de8a1e2020-09-18 14:15:30 -07003426// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3427// to match the topological order of the dependency tree, including any static analogues of
Colin Crossa14fb6a2024-10-23 16:57:06 -07003428// direct shared libraries. It returns the ordered static dependencies, and a depset.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07003429// of the transitive dependencies.
Colin Crossa14fb6a2024-10-23 16:57:06 -07003430func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive depset.DepSet[android.Path]) {
3431 transitiveStaticLibsBuilder := depset.NewBuilder[android.Path](depset.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003432 var staticPaths android.Paths
3433 for _, staticDep := range staticDeps {
3434 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3435 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3436 }
3437 for _, sharedDep := range sharedDeps {
Colin Crossa14fb6a2024-10-23 16:57:06 -07003438 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003439 }
3440 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3441
3442 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3443
3444 // reorder the dependencies based on transitive dependencies
3445 staticPaths = android.FirstUniquePaths(staticPaths)
3446 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3447
3448 if len(orderedStaticPaths) != len(staticPaths) {
3449 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3450 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3451 }
3452
3453 return orderedStaticPaths, transitiveStaticLibs
3454}
3455
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003456// BaseLibName trims known prefixes and suffixes
3457func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003458 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3459 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003460 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003461 return libName
3462}
3463
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003464func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003465 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003466 ccDepModule, _ := ccDep.(*Module)
3467 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003468 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003469
Justin Yuncbca3732021-02-03 19:24:13 +09003470 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003471 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003472 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003473 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003474
Ivan Lozanod1dec542021-05-26 15:33:11 -04003475 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003476 }
3477 }
3478
Kiyoung Kim22152f62024-05-24 10:45:28 +09003479 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003480 // The vendor and product modules in Make will have been renamed to not conflict with the
3481 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003482 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003483 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003484 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003485 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003486 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003487 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003488 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003489 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003490 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003491 } else {
3492 return libName
3493 }
3494}
3495
Colin Crossca860ac2016-01-04 14:34:37 -08003496func (c *Module) InstallInData() bool {
3497 if c.installer == nil {
3498 return false
3499 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003500 return c.installer.inData()
3501}
3502
3503func (c *Module) InstallInSanitizerDir() bool {
3504 if c.installer == nil {
3505 return false
3506 }
3507 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003508 return true
3509 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003510 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003511}
3512
Yifan Hong1b3348d2020-01-21 15:53:22 -08003513func (c *Module) InstallInRamdisk() bool {
3514 return c.InRamdisk()
3515}
3516
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003517func (c *Module) InstallInVendorRamdisk() bool {
3518 return c.InVendorRamdisk()
3519}
3520
Jiyong Parkf9332f12018-02-01 00:54:12 +09003521func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003522 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003523}
3524
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003525func (c *Module) MakeUninstallable() {
3526 if c.installer == nil {
3527 c.ModuleBase.MakeUninstallable()
3528 return
3529 }
3530 c.installer.makeUninstallable(c)
3531}
3532
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003533func (c *Module) HostToolPath() android.OptionalPath {
3534 if c.installer == nil {
3535 return android.OptionalPath{}
3536 }
3537 return c.installer.hostToolPath()
3538}
3539
Nan Zhangd4e641b2017-07-12 12:55:28 -07003540func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3541 return c.outputFile
3542}
3543
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003544func (c *Module) static() bool {
3545 if static, ok := c.linker.(interface {
3546 static() bool
3547 }); ok {
3548 return static.static()
3549 }
3550 return false
3551}
3552
Colin Cross6a730042024-12-05 13:53:43 -08003553func (c *Module) staticLibrary() bool {
3554 if static, ok := c.linker.(interface {
3555 staticLibrary() bool
3556 }); ok {
3557 return static.staticLibrary()
3558 }
3559 return false
3560}
3561
Jiyong Park379de2f2018-12-19 02:47:14 +09003562func (c *Module) staticBinary() bool {
3563 if static, ok := c.linker.(interface {
3564 staticBinary() bool
3565 }); ok {
3566 return static.staticBinary()
3567 }
3568 return false
3569}
3570
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003571func (c *Module) testBinary() bool {
3572 if test, ok := c.linker.(interface {
3573 testBinary() bool
3574 }); ok {
3575 return test.testBinary()
3576 }
3577 return false
3578}
3579
Jingwen Chen537242c2022-08-24 11:53:27 +00003580func (c *Module) testLibrary() bool {
3581 if test, ok := c.linker.(interface {
3582 testLibrary() bool
3583 }); ok {
3584 return test.testLibrary()
3585 }
3586 return false
3587}
3588
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003589func (c *Module) benchmarkBinary() bool {
3590 if b, ok := c.linker.(interface {
3591 benchmarkBinary() bool
3592 }); ok {
3593 return b.benchmarkBinary()
3594 }
3595 return false
3596}
3597
3598func (c *Module) fuzzBinary() bool {
3599 if f, ok := c.linker.(interface {
3600 fuzzBinary() bool
3601 }); ok {
3602 return f.fuzzBinary()
3603 }
3604 return false
3605}
3606
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003607// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3608func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003609 if h, ok := c.linker.(interface {
3610 header() bool
3611 }); ok {
3612 return h.header()
3613 }
3614 return false
3615}
3616
Ivan Lozanod7586b62021-04-01 09:49:36 -04003617func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003618 if b, ok := c.linker.(interface {
3619 binary() bool
3620 }); ok {
3621 return b.binary()
3622 }
3623 return false
3624}
3625
Justin Yun5e035862021-06-29 20:50:37 +09003626func (c *Module) StaticExecutable() bool {
3627 if b, ok := c.linker.(*binaryDecorator); ok {
3628 return b.static()
3629 }
3630 return false
3631}
3632
Ivan Lozanod7586b62021-04-01 09:49:36 -04003633func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003634 if o, ok := c.linker.(interface {
3635 object() bool
3636 }); ok {
3637 return o.object()
3638 }
3639 return false
3640}
3641
Kiyoung Kim37693d02024-04-04 09:56:15 +09003642func (m *Module) Dylib() bool {
3643 return false
3644}
3645
3646func (m *Module) Rlib() bool {
3647 return false
3648}
3649
Ivan Lozanof9e21722020-12-02 09:00:51 -05003650func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003651 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003652 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003653 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003654 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003655 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003656 return "native:product"
3657 }
Jooyung Han38002912019-05-16 04:01:54 +09003658 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003659 } else if c.InRamdisk() {
3660 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003661 } else if c.InVendorRamdisk() {
3662 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003663 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003664 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003665 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003666 return "native:ndk:none:none"
3667 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3668 //family, link := getNdkStlFamilyAndLinkType(c)
3669 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3670 } else {
3671 return "native:platform"
3672 }
3673}
3674
Jiyong Park9d452992018-10-03 00:38:19 +09003675// Overrides ApexModule.IsInstallabeToApex()
Colin Cross3a02c7b2024-05-21 13:46:22 -07003676// Only shared/runtime libraries .
Jiyong Park9d452992018-10-03 00:38:19 +09003677func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003678 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003679 // Stub libs and prebuilt libs in a versioned SDK are not
3680 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003681 return lib.shared() && !lib.buildStubs()
Jiyong Park9d452992018-10-03 00:38:19 +09003682 }
3683 return false
3684}
3685
Jiyong Parka90ca002019-10-07 15:47:24 +09003686func (c *Module) AvailableFor(what string) bool {
Yu Liub73c3a62024-12-10 00:58:06 +00003687 return android.CheckAvailableForApex(what, c.ApexAvailableFor())
3688}
3689
3690func (c *Module) ApexAvailableFor() []string {
3691 list := c.ApexModuleBase.ApexAvailable()
Jiyong Parka90ca002019-10-07 15:47:24 +09003692 if linker, ok := c.linker.(interface {
Yu Liub73c3a62024-12-10 00:58:06 +00003693 apexAvailable() []string
Jiyong Parka90ca002019-10-07 15:47:24 +09003694 }); ok {
Yu Liub73c3a62024-12-10 00:58:06 +00003695 list = append(list, linker.apexAvailable()...)
Jiyong Parka90ca002019-10-07 15:47:24 +09003696 }
Yu Liub73c3a62024-12-10 00:58:06 +00003697
3698 return android.FirstUniqueStrings(list)
Jiyong Parka90ca002019-10-07 15:47:24 +09003699}
3700
Paul Duffin0cb37b92020-03-04 14:52:46 +00003701func (c *Module) EverInstallable() bool {
3702 return c.installer != nil &&
3703 // Check to see whether the module is actually ever installable.
3704 c.installer.everInstallable()
3705}
3706
Ivan Lozanod7586b62021-04-01 09:49:36 -04003707func (c *Module) PreventInstall() bool {
3708 return c.Properties.PreventInstall
3709}
3710
3711func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003712 if c.library != nil {
3713 if i := c.library.installable(); i != nil {
3714 return i
3715 }
3716 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003717 return c.Properties.Installable
3718}
3719
3720func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003721 ret := c.EverInstallable() &&
3722 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003723 proptools.BoolDefault(c.Installable(), true) &&
3724 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003725
3726 // The platform variant doesn't need further condition. Apex variants however might not
3727 // be installable because it will likely to be included in the APEX and won't appear
3728 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003729 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003730 return ret
3731 }
3732
3733 // Special case for modules that are configured to be installed to /data, which includes
3734 // test modules. For these modules, both APEX and non-APEX variants are considered as
3735 // installable. This is because even the APEX variants won't be included in the APEX, but
3736 // will anyway be installed to /data/*.
3737 // See b/146995717
3738 if c.InstallInData() {
3739 return ret
3740 }
3741
3742 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003743}
3744
Logan Chien41eabe62019-04-10 13:33:58 +08003745func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3746 if c.linker != nil {
3747 if library, ok := c.linker.(*libraryDecorator); ok {
3748 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3749 }
3750 }
3751}
3752
Jiyong Park45bf82e2020-12-15 22:29:02 +09003753var _ android.ApexModule = (*Module)(nil)
3754
3755// Implements android.ApexModule
Colin Crossf7bbd2f2024-12-05 13:57:10 -08003756func (c *Module) OutgoingDepIsInSameApex(depTag blueprint.DependencyTag) bool {
Colin Crossc1b36442021-05-06 13:42:48 -07003757 if depTag == stubImplDepTag {
3758 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003759 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003760 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003761 if depTag == staticVariantTag {
3762 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3763 // actually mean that the static lib (and its dependencies) are copied into the
3764 // APEX.
3765 return false
3766 }
Colin Cross8acea3e2024-12-12 14:53:30 -08003767
3768 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3769 if isLibDepTag && c.static() && libDepTag.shared() {
3770 // shared_lib dependency from a static lib is considered as crossing
3771 // the APEX boundary because the dependency doesn't actually is
3772 // linked; the dependency is used only during the compilation phase.
3773 return false
3774 }
3775
3776 if isLibDepTag && libDepTag.excludeInApex {
3777 return false
3778 }
3779
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003780 return true
3781}
3782
Colin Crossf7bbd2f2024-12-05 13:57:10 -08003783func (c *Module) IncomingDepIsInSameApex(depTag blueprint.DependencyTag) bool {
Colin Crossf7bbd2f2024-12-05 13:57:10 -08003784 if c.HasStubsVariants() {
3785 if IsSharedDepTag(depTag) {
3786 // dynamic dep to a stubs lib crosses APEX boundary
3787 return false
3788 }
3789 if IsRuntimeDepTag(depTag) {
3790 // runtime dep to a stubs lib also crosses APEX boundary
3791 return false
3792 }
3793 if IsHeaderDepTag(depTag) {
3794 return false
3795 }
3796 }
3797 if c.IsLlndk() {
3798 return false
3799 }
Colin Crossf7bbd2f2024-12-05 13:57:10 -08003800
3801 return true
3802}
3803
Jiyong Park45bf82e2020-12-15 22:29:02 +09003804// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003805func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3806 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003807 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3808 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3809 return nil
3810 }
Jooyung Han749dc692020-04-15 11:03:39 +09003811 // We don't check for prebuilt modules
3812 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3813 return nil
3814 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003815
Jooyung Han749dc692020-04-15 11:03:39 +09003816 minSdkVersion := c.MinSdkVersion()
3817 if minSdkVersion == "apex_inherit" {
3818 return nil
3819 }
3820 if minSdkVersion == "" {
3821 // JNI libs within APK-in-APEX fall into here
3822 // Those are okay to set sdk_version instead
3823 // We don't have to check if this is a SDK variant because
3824 // non-SDK variant resets sdk_version, which works too.
3825 minSdkVersion = c.SdkVersion()
3826 }
Dan Albertc8060532020-07-22 22:32:17 -07003827 if minSdkVersion == "" {
3828 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3829 }
3830 // Not using nativeApiLevelFromUser because the context here is not
3831 // necessarily a native context.
3832 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003833 if err != nil {
3834 return err
3835 }
Dan Albertc8060532020-07-22 22:32:17 -07003836
Colin Cross8ca61c12022-10-06 21:00:14 -07003837 // A dependency only needs to support a min_sdk_version at least
3838 // as high as the api level that the architecture was introduced in.
3839 // This allows introducing new architectures in the platform that
3840 // need to be included in apexes that normally require an older
3841 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003842 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003843 if sdkVersion.LessThan(minApiForArch) {
3844 sdkVersion = minApiForArch
3845 }
3846
Dan Albertc8060532020-07-22 22:32:17 -07003847 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003848 return fmt.Errorf("newer SDK(%v)", ver)
3849 }
3850 return nil
3851}
3852
Paul Duffinb5769c12021-05-12 16:16:51 +01003853// Implements android.ApexModule
3854func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3855 // stub libraries and native bridge libraries are always available to platform
3856 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3857}
3858
Inseob Kima1888ce2022-10-04 14:42:02 +09003859func (c *Module) overriddenModules() []string {
3860 if o, ok := c.linker.(overridable); ok {
3861 return o.overriddenModules()
3862 }
3863 return nil
3864}
3865
Liz Kammer35ca77e2021-12-22 15:31:40 -05003866type moduleType int
3867
3868const (
3869 unknownType moduleType = iota
3870 binary
3871 object
3872 fullLibrary
3873 staticLibrary
3874 sharedLibrary
3875 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003876 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003877 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003878)
3879
3880func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003881 if c.testBinary() {
3882 // testBinary is also a binary, so this comes before the c.Binary()
3883 // conditional. A testBinary has additional implicit dependencies and
3884 // other test-only semantics.
3885 return testBin
3886 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003887 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003888 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003889 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003890 } else if c.testLibrary() {
3891 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3892 // will let them add implicit compile deps on gtest, for example.
3893 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003894 // For now, treat them as regular libraries.
3895 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003896 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003897 static := false
3898 shared := false
3899 if library, ok := c.linker.(*libraryDecorator); ok {
3900 static = library.MutatedProperties.BuildStatic
3901 shared = library.MutatedProperties.BuildShared
3902 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3903 static = library.MutatedProperties.BuildStatic
3904 shared = library.MutatedProperties.BuildShared
3905 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003906 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003907 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003908 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003909 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003910 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003911 return staticLibrary
3912 }
3913 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003914 } else if c.isNDKStubLibrary() {
3915 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003916 }
3917 return unknownType
3918}
3919
Colin Crosscfad1192015-11-02 16:43:11 -08003920// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003921type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003922 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003923 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003924 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003925}
3926
Patrice Arrudac249c712019-03-19 17:00:29 -07003927// cc_defaults provides a set of properties that can be inherited by other cc
3928// modules. A module can use the properties from a cc_defaults using
3929// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3930// merged (when possible) by prepending the default module's values to the
3931// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003932func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003933 return DefaultsFactory()
3934}
3935
Colin Cross36242852017-06-23 15:06:31 -07003936func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003937 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003938
Colin Cross36242852017-06-23 15:06:31 -07003939 module.AddProperties(props...)
3940 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003941 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003942 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003943 &BaseCompilerProperties{},
3944 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003945 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003946 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003947 &StaticProperties{},
3948 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003949 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003950 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003951 &TestLinkerProperties{},
3952 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003953 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003954 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003955 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003956 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003957 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003958 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003959 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003960 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003961 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003962 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003963 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003964 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00003965 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003966 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003967 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3968 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003969 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003970 )
Colin Crosscfad1192015-11-02 16:43:11 -08003971
Jooyung Hancc372c52019-09-25 15:18:44 +09003972 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003973
3974 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003975}
3976
Jiyong Park2286afd2020-06-16 21:58:53 +09003977func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003978 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003979}
3980
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003981func kytheExtractAllFactory() android.Singleton {
3982 return &kytheExtractAllSingleton{}
3983}
3984
3985type kytheExtractAllSingleton struct {
3986}
3987
3988func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3989 var xrefTargets android.Paths
Yu Liuec7043d2024-11-05 18:22:20 +00003990 ctx.VisitAllModuleProxies(func(module android.ModuleProxy) {
3991 files := android.OtherModuleProviderOrDefault(ctx, module, CcObjectInfoProvider).kytheFiles
3992 if len(files) > 0 {
3993 xrefTargets = append(xrefTargets, files...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003994 }
3995 })
3996 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3997 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003998 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003999 }
4000}
4001
Jihoon Kangf78a8902022-09-01 22:47:07 +00004002func (c *Module) Partition() string {
4003 if p, ok := c.installer.(interface {
4004 getPartition() string
4005 }); ok {
4006 return p.getPartition()
4007 }
4008 return ""
4009}
4010
Spandan Das2b6dfb52024-01-19 00:22:22 +00004011type sourceModuleName interface {
4012 sourceModuleName() string
4013}
4014
4015func (c *Module) BaseModuleName() string {
4016 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
4017 // if the prebuilt module sets a source_module_name in Android.bp, use that
4018 return smn.sourceModuleName()
4019 }
4020 return c.ModuleBase.BaseModuleName()
4021}
4022
Spandan Dase20c56c2024-07-23 21:34:24 +00004023func (c *Module) stubsSymbolFilePath() android.Path {
4024 if library, ok := c.linker.(*libraryDecorator); ok {
4025 return library.stubsSymbolFilePath
4026 }
4027 return android.OptionalPath{}.Path()
4028}
4029
Colin Cross06a931b2015-10-28 17:23:31 -07004030var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004031var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004032var BoolPtr = proptools.BoolPtr
4033var String = proptools.String
4034var StringPtr = proptools.StringPtr